Willis丶
Willis丶

1.初窥Mybatis初始化

引言

这篇文章呢，主要是讲Mybtais的两种方式的源码剖析：传统方式以及Mapper代理方式，初次探索Mybatis源码，希望大佬勿喷并且指正错误，谢谢！

个人博客：www.fqcoder.cn

一、Mybatis架构原理

1.架构图

首先，让我们来看看下面这张图：
1.初窥Mybatis初始化_第1张图片

我们吧Mybtais功能架构可以分为三层：

1.接口层：提供给外部使用的接口API，开发人员通过这些本地API来操作数据库。接口一层接收到调用请求就会调用数据处理来完成具体的数据处理。

MyBatis和数据库交互有两种方式：（也是我们接下来需要死磕的目标）

a.使用传统的Mybatis提供的API

b.使用Mapper代理的方式

2.数据处理层：负责具体的SQL查找、SQL解析、SQL执行、结果处理和映射等，它主要的目的是根据调用的请求完成一次数据库的操作。

3.框架支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。

2.主要构件及其相互关系

构件 描述
SqlSession 作为MyBatis工作主要顶层API，表示和数据库交互的会话，完成必要数据库
增删改查功能
Executor Mybatis执行器，是Mybatis调度的核心，负责SQL语句的生成和查询缓存的维护
StatementHandler 封装了JDBC Statemenet操作，负责对JDBC Statement的操作，如设置参数、
将Statement结果集转换成List集合
ParameterHandler 负责对用户传递的参数转换成JDBC Statement所需要的参数
ResultSetHandler 负责将JDBC返回的ResultSet结果集对象转换成List类型的集合
TypeHandler 负责java数据类型和jdbc数据类型之间的映射和转换
MappedStatement MappedStatement维护了一条
SqlSource 负责根据用户传递的parameterObject，动态的生成SQL语句，将信息分封装到
BoundSql对象中，并返回
BoundSql 表示动态生成的SQL语句以及相应的参数信息

3.层次结构图

下面这张图就是Mybatis流程的层次结构图，建议读源码的时候记得打开这张图，思路才不会乱呢
1.初窥Mybatis初始化_第2张图片

4.总体流程

（1）加载配置文件并初始化

配置来源两个地方，一个是配置文件（主配置文件confi.xml，Mapper文件.xml）,一个是Java代码中的注解，将主配置为恩建内容解析封装到Configuration,将sql的配置信息加载成为一个mappedStatement对象，存储在内存之中

（2）接收调用请求

将请求传递给下层的请求处理层进行处理

（3）处理操作请求

A.根据SQL的ID查找对一个的MappedStatement对象

B.根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数

C.获取数据库连接，根据得到的最终SQL语句执行传入参数到数据库执行，并得到执行结果

D.根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果

E.释放连接资源

（4）返回处理结果

将最终的处理结果返回

二、死磕Mybatis源码剖析

1）传统方式的源码剖析

读取配置文件就不进去看了，第二行代码，才是初始化工作的开始

  //1.读取配置文件，读成字节输入流：还未解析
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    
  //2.解析XMl配置文件，封装成Configuration对象，创建DefaultSqlSessionFactory对象
  SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

我们进入build（）方法里看看：

  //1.我们最初调用的build
  public SqlSessionFactory build(InputStream inputStream) {
    //调用了重载方法
    return build(inputStream, null, null);
  }

发现调用了一个重载的方法，我们点进build()去看看：

//2.调用的重载方法
  public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
      //创建XML ConfigBuilder,XML configBuilder 是专门解析MyBatis的配置文件的类
      XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
      //执行XML解析
      //创建DefaultSqlSessionFactory对象
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        inputStream.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

发现创建了parser.parse()的返回值是configuration对象，是专门解析Mybatis的配置文件的类，

Mybatis在初始化的时候，会将Mybatis的配置信息全部加载到内存中，使用org.apache.ibatis.session.Configuration实例来维护，我们在进去parse()方法里看看：

  /**
   * 解析XML 成 Configuration对象
   * @return Configuration对象
   */
  public Configuration parse() {
    //若已解析，抛出BuilderException异常
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    //标记已经解析
    parsed = true;
    //parser是XPathParser解析器对象，读取节内数据，是Mybatis配置文件的顶层标签
    //解析XML configuration节点
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

我们看看是怎么解析configuration节点的，我们再点进parseConfiguration()方法里看看：

/**
   * 解析 XML
   *
   * 具体 My
   * @param root 根节点
   */
  private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      //解析标签
      propertiesElement(root.evalNode("properties"));
      //解析标签
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      //加载自定义的VFS实现类
      loadCustomVfs(settings);
      //加载自定义的LOG实现类
      loadCustomLogImpl(settings);
      //解析标签
      typeAliasesElement(root.evalNode("typeAliases"));
      //解析标签
      pluginElement(root.evalNode("plugins"));
      //解析标签
      objectFactoryElement(root.evalNode("objectFactory"));
      //解析标签
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      //解析标签
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      //赋值到 Configuration 属性
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      //解析标签
      environmentsElement(root.evalNode("environments"));
      //解析标签
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      //解析标签
      typeHandlerElement(root.evalNode("typeHandlers"));
      //解析解析
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

是不是发现这里面都是解析配置文件里的标签，我们随便点进一个方法里，以propertiesElement()方法为例，我们再进去看看：

/**
   * 1.解析  标签,成 Properties 对象
   * 2.覆盖 configuration 中的 Properties 对象到上面的结果
   * 3.设置结果到 parser 和 configuration 中
   *
   * @param context 节点
   * @throws Exception 解析发生异常
   */
  private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
      //读取子标签们，为 Properties对象
      Properties defaults = context.getChildrenAsProperties();
      //读取 resource 和 url 属性
      String resource = context.getStringAttribute("resource");
      String url = context.getStringAttribute("url");
      //resource 和 url 都存在的情况下,抛出 BuilderException 异常
      if (resource != null && url != null) {
        throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
      }
      //读取本地 properties 配置文件到 defaults 中
      if (resource != null) {
        defaults.putAll(Resources.getResourceAsProperties(resource));
        //读取远程 properties 配置文件到defaults中
      } else if (url != null) {
        defaults.putAll(Resources.getUrlAsProperties(url));
      }
      //覆盖 configuration中的 properties对象到defaults中
      Properties vars = configuration.getVariables();
      if (vars != null) {
        defaults.putAll(vars);
      }
      //设置 defaults 到 parser 和 configuration 中
      parser.setVariables(defaults);
      configuration.setVariables(defaults);
    }
  }

好了，到了这里发现，初始化配置文件的本质就是创建configuration对象，将解析的xml数据封装到Configuration内部属性中。

然后我们再回到开头，我再贴一下代码：

    //1.读取配置文件，读成字节输入流：还未解析
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

    //2.解析XMl配置文件，封装成Configuration对象，创建DefaultSqlSessionFactory对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

    //3.生产了DefaultSqlSession实例对象 设置了事务不自动提交  完成了executor 对象的创建
    SqlSession sqlSession=sqlSessionFactory.openSession();

初始化完毕之后，我们就要开始执行SQL了，获得sqlSession,在这之前，我先简单介绍一下SqlSession：

SqlSession是一个接口，他有两个实现类DefaultSqlSession（默认）和SqlSessionManager（弃用）

SqlSession是Mybatis中用于和数据库交互的顶层类，通常将它与ThreadLocal绑定，一个会话使用一个SqlSession，并且在使用完毕之后需要close。

public class DefaultSqlSession implements SqlSession {
	private final Configuration configuration;
	private final Executor executor;
	.......略
}
SqlSession中两个最重要的参数，configuration与初始化时的相同，executor为执行器

我们继续，进入openSession（）方法看看：

 @Override
  public SqlSession openSession() {
    //getDefaultExecutorType()传递的是SimpleExecutor
    return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
  }

我们进openSessionFromDataSource（）:

/**
   *
   * @param execType Executor的类型
   * @param level 事务隔离级别
   * @param autoCommit 是否开启事务
   * @return
   */
  //openSession的多个重载方法可以指定获得的SqlSession的Executor类型和事务的处理
  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      //获的 Environment 对象
      final Environment environment = configuration.getEnvironment();
      //创建 TransactionFactory 对象
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      //创建 Executor 对象
      final Executor executor = configuration.newExecutor(tx, execType);
      //创建DefaultSqlSession 对象
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      //如果发生异常，则关闭 Transaction 对象
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

发现openSessionFromDataSource返回了一个DefaultSqlSession实例对象，设置了事务不自动提交，完成了executor 对象的创建，接下来，就要执行sqlSession中的api了：

	 /**
     * 1.根据Statement Id 来从Configuration中map集合中获取到了指定的MappedStatement对象
     * 2.将查询任务委派了executor执行器
     */
    List<Object> objects = sqlSession.selectList("com.fqcoder.mapper.UserMapper.getUserName");

我们进selectList()方法看看，发现是多个重载方法：

//进入 selectList 方法，多个重载方法
  @Override
  public <E> List<E> selectList(String statement) {
    return this.selectList(statement, null);
  }

  @Override
  public <E> List<E> selectList(String statement, Object parameter) {
    return this.selectList(statement, parameter, RowBounds.DEFAULT);
  }

  @Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      //获得 MappedStatement对象
      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();
    }
  }

我们进入executor.query()

  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    //根据传入的参数动态获取SQL语句，最后返回用BoundSql对象表示
    BoundSql boundSql = ms.getBoundSql(parameter);
    //为本次查询创建缓存的key
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    //查询
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
  }

进入query的重载方法中：

@SuppressWarnings("unchecked")
  @Override
  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());
    //已经关闭，则抛出ExecutorException异常
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    //清空本地换成，如果queryStack为零，并且要求清空本地缓存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      //queryStack +1
      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();
      }
      // issue #601
      deferredLoads.clear();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }

我们继续 ，进入queryFromDatabase（）方法：

//从数据库中读取操作
  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抽象方法，发现底层是通过jdbc来操作的数据库的

 @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      //获取configuration对象
      Configuration configuration = ms.getConfiguration();
      //传入参数创建 StatementHandler对象来执行查询
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      //创建jdbc中的statement对象
      stmt = prepareStatement(handler, ms.getStatementLog());
      //执行StatementHandler,进行读操作
      return handler.query(stmt, resultHandler);
    } finally {
      //关闭 StatementHandler 对象
      closeStatement(stmt);
    }
  }

我们在进去prepareStatement()方法看看：

//初始化 StatementHandler 对象
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  //获得 Connection对象
  Connection connection = getConnection(statementLog);
  //创建 Statement 或 PrepareStatement对象
  stmt = handler.prepare(connection, transaction.getTimeout());
  //设置SQL上的参数，例如 PrepareStatement 对象上的占位符
  handler.parameterize(stmt);
  return stmt;
}

进入getConnection方法：经过重重的调用，最后调用openConnection（），从连接池获取连接

protected void openConnection() throws SQLException {
  if (log.isDebugEnabled()) {
    log.debug("Opening JDBC Connection");
  }
  //从连接池获取连接的方法
  connection = dataSource.getConnection();
  if (level != null) {
    connection.setTransactionIsolation(level.getLevel());
  }
  setDesiredAutoCommit(autoCommit);
}

我们停下来回想一下，上面的executor.query()方法，经过几经波折，最后会创建一个StatementHandler对象，然后将必要的参数传递给 StatementHandler,使用StatementHandler来完成对数据库的查询，最终返回List结果集。

从上面的代码中我们可以看出，Executor的功能和作用是：

1）根据传递的参数，完成SQL语句的动态解析，生产BoundSql对象，供StatementHandler使用；

2）为查询创建缓存，以提高性能

3）创建JDBC的Statement连接对象，传递给 StatemenetHandler对象，返回List查询结果

接下来我们再了解一下StatementHandler对象，它主要完成两个工作：

1）对于JDBC的PreparedStatemenet类型的对象，创建的过程中，我们使用的Sql语句字符串会包含若干个 ?占位符，我们再对占位符进行设值，StatementHandler通过parameterize(statement)方法对Statement进行设值

2）StatementHandler通过List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的ResultSet封装成List

我们进入到StatementHandler的parameterize(statement)方法的实现看看：

@Override
public void parameterize(Statement statement) throws SQLException {
  //使用ParameterHandler对象来完成对Statement的设值
  parameterHandler.setParameters((PreparedStatement) statement);
}

进入 setParameters() 方法

@Override
public void setParameters(PreparedStatement ps) {
  ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
  //遍历parameterMappings数组
  List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  if (parameterMappings != null) {
    for (int i = 0; i < parameterMappings.size(); i++) {
      //获得遍历parameterMapping对象
      ParameterMapping parameterMapping = parameterMappings.get(i);
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        //获得值
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        //获得 typeHandler、jdbcType属性
        TypeHandler typeHandler = parameterMapping.getTypeHandler();
        JdbcType jdbcType = parameterMapping.getJdbcType();
        if (value == null && jdbcType == null) {
          jdbcType = configuration.getJdbcTypeForNull();
        }
        //设置 ？ 占位符的参数
        try {
          typeHandler.setParameter(ps, i + 1, value, jdbcType);
        } catch (TypeException | SQLException e) {
          throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
        }
      }
    }
  }
}

上面这些代码可以看到StatementHandler.parameterize(Statement)方法调用了ParameterHandle.setParameters(statement)方法，ParameterHandler.setParameters(Statement)方法负责根据我们输入的参数，对Statement对象的 ?占位符处进行赋值。

现在我们再回到SimpleExecutor类中的doQuery()方法，我们继续往下，进入hander.query()方法：

@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    //调用PreparedStatement.execute（）方法，然后将resultSet交给ResultSetHandler处理
  PreparedStatement ps = (PreparedStatement) statement;
  //执行查询
  ps.execute();
  //处理返回结果
  return resultSetHandler.handleResultSets(ps);
}

从上面的代码可以看出来，‬StatementHandler的List query(Statement statement, ResultHandler
resultHandler）方法的实现，是调用了ResultSetHandler.handleResultSets(Statement)方法。
ResultSetHandler.handleResultSets(Statement)方法会将Statement语句执行后生产的resultSet 结果集转换成List结果集

我们再继续看handleResultSets（）方法：

@Override
public List<Object> handleResultSets(Statement stmt) throws SQLException {
  ErrorContext.instance().activity("handling results").object(mappedStatement.getId());

  //多 ResultSet 的结果集合,每个ResultSet 对应一个Object 对象，实际上，每个Object 是List对象
  //在不考虑存储过程的多ResultSet 的情况下，普通的查询，实际就一个ResultSet,也就是说，multipleResults最多就一个元素
  final List<Object> multipleResults = new ArrayList<>();

  int resultSetCount = 0;
  //获得首个 ResultSet对象，并封装成 ResultSetWrapper对象
  ResultSetWrapper rsw = getFirstResultSet(stmt);

  //获得ResultMap数组
  //在不考虑存储过程的多ResultSet的情况  普通的查询，实际就是一个 ResultSet,也就是说resultMap 就一个元素
  List<ResultMap> resultMaps = mappedStatement.getResultMaps();
  int resultMapCount = resultMaps.size();
  validateResultMapsCount(rsw, resultMapCount);//校验
  while (rsw != null && resultMapCount > resultSetCount) {
    //获得ResultMap对象
    ResultMap resultMap = resultMaps.get(resultSetCount);
    //处理ResultSet，将结果添加到multipleResults中
    handleResultSet(rsw, resultMap, multipleResults, null);
    //获得下一个ResultSet对象，并封装成 ResultSetWrapper对象
    rsw = getNextResultSet(stmt);
    //清理
    cleanUpAfterHandlingResultSet();
    //resultSetCount++
    resultSetCount++;
  }

  String[] resultSets = mappedStatement.getResultSets();
  if (resultSets != null) {
    while (rsw != null && resultSetCount < resultSets.length) {
      ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
      if (parentMapping != null) {
        String nestedResultMapId = parentMapping.getNestedResultMapId();
        ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
        handleResultSet(rsw, resultMap, null, parentMapping);
      }
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }
  }
//如果是 multipleResults 单元素，则取首元素返回
  return collapseSingleResultList(multipleResults);
}



好了，看到这里，我们回想一下上面的层次结构图，接下来我们在看看Mapper代理方法的源码


2）Mapper代理方式的源码剖析


话不多说，让我们先回顾一下写法：


/**
 * mapper代理方式
 * @throws IOException
 */
public void test2()throws IOException{
    //前3步都是相同的
  InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
  SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
  SqlSession sqlSession=sqlSessionFactory.openSession();

  //使用JDK动态代理对Mapper借口产生代理对象
  IUserMapper userMapper=sqlSession.getMapper(IUserMapper.class);
  List<Object> objects = userMapper.queryAll();
}




我们点进sqlSession.getMppaer()方法里：


//DefaultSqlSession里的getMapper()
@Override
public <T> T getMapper(Class<T> type) {
  return configuration.getMapper(type, this);
}

//Configuration里的getMapper()
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

//MapperRegistry里的getMapper()
 @SuppressWarnings("unchecked")
  public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    //获得MapperProxyFactory对象
    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
    //不存在 则跑出BindingException异常
    if (mapperProxyFactory == null) {
      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
    }
    //通过动态代理工厂生产实例
    try {
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }




发现Mapper代理方式底层是利用了动态代理，我们在进mapperProxyFactory.newInstance（）方法：


//MapperProxyFactory类中的newInstance方法
public T newInstance(SqlSession sqlSession) {
  //创建了jdk动态代理的invocationHandler接口的实现类mapperProxy
  final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
  //调用了重载方法
  return newInstance(mapperProxy);
}



 @SuppressWarnings("unchecked")
protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }




然后我们再看看MapperProxy这个类的invoke()方法：


@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  try {
    //如果是Object定义的方法  直接调用
    if (Object.class.equals(method.getDeclaringClass())) {
      return method.invoke(this, args);
    } else {
      return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
    }
  } catch (Throwable t) {
    throw ExceptionUtil.unwrapThrowable(t);
  }
}




我们再点进cachedInvoker(method).invoke（）方法里看看


@Override
public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
    //
  return mapperMethod.execute(sqlSession, args);
}




发现 MapperMethod最终调用了execute()方法,我们继续点进去看看：


public Object execute(SqlSession sqlSession, Object[] args) {
  Object result;
  //判断mapper中方法类型  最终调用的还是SqlSession中的方法
  switch (command.getType()) {
    case INSERT: {
        //转换参数
      Object param = method.convertArgsToSqlCommandParam(args);
        //执行INSERT操作
        //转换rowCount
      result = rowCountResult(sqlSession.insert(command.getName(), param));
      break;
    }
    case UPDATE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.update(command.getName(), param));
      break;
    }
    case DELETE: {
      Object param = method.convertArgsToSqlCommandParam(args);
      result = rowCountResult(sqlSession.delete(command.getName(), param));
      break;
    }
    case SELECT:
          //无返回，并且有ResulyHandler方法参数，则将查询的结果，提交给ResultHandler 进行处理
      if (method.returnsVoid() && method.hasResultHandler()) {
        executeWithResultHandler(sqlSession, args);
        result = null;
          //执行查询，返回列表
      } else if (method.returnsMany()) {
        result = executeForMany(sqlSession, args);
          //执行查询，返回Map
      } else if (method.returnsMap()) {
        result = executeForMap(sqlSession, args);
          //返回Cursor
      } else if (method.returnsCursor()) {
        result = executeForCursor(sqlSession, args);
      } else {
          //返回单个对象
        Object param = method.convertArgsToSqlCommandParam(args);
          //查询单条
        result = sqlSession.selectOne(command.getName(), param);
        if (method.returnsOptional()
            && (result == null || !method.getReturnType().equals(result.getClass()))) {
          result = Optional.ofNullable(result);
        }
      }
      break;
    case FLUSH:
      result = sqlSession.flushStatements();
      break;
    default:
      throw new BindingException("Unknown execution method for: " + command.getName());
  }
  if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
    throw new BindingException("Mapper method '" + command.getName()
        + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
  }
    //返回结果集
  return result;
}




上面代码发现，它最终调用的还是SqlSession里的方法

























你可能感兴趣的:(Mybatis)






    

  • insert into select 主键自增_mybatis拦截器实现主键自动生成
weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id

    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
    

    • 

  • MyBatis 详解
阿贾克斯的黎明
javamybatis

    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
    

    • 

  • mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析
weixin_39844942
mybatis二级缓存失效

    这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
    

    • 

  • 详解mybatis的一二级缓存以及缓存失效原因
仰望天花板
缓存数据库mybatisjavamysql

    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
    

    • 

  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
这孩子叫逆
Mybatis笔记mybatis数据库

    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    

    • 

  • MyBatis批量插入大量数据
小黑屋说YYDS
MyBatisjava

    1.思路分析批量插入这个问题，我们用JDBC操作，其实就是两种思路吧：用一个for循环，把数据一条一条的插入（这种需要开启批处理）。生成一条插入sql，类似这种insertintouser(username,address)values(‘aa’,‘bb’),(‘cc’,‘dd’)…。到底哪种快呢？我们从两方面来考虑这个问题：插入SQL本身执行的效率。网络I/O。先说第一种方案，就是用for循环循
    

    • 

  • MyBatis 查询数据库_mybatis查询某个库的所有表名(2)
2401_84181942
程序员mybatisoracletomcat

    标签说明：***``标签**：需要指定namespace属性，表示命名空间，值为mapper接口的全限定名，包括全包名.类名。***``查询标签**：是用来执行数据库的查询操作的：`id`：是和Interface（接口）中定义的方法名称一样的，表示对接口的具体实现方法。`resultType`：是返回的数据类型，也就是开头我们定义的实体类。####2.4.4添加Service服务层实现代码如下：@
    

    • 

  • 5-【JavaWeb】JUnit 单元测试及JUL 日志系统
weixin_44329069
JavaWebjunit单元测试

    1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
    

    • 

  • 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目
计算机学姐来啦
springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee

    收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
    

    • 

  • MyBatis系统学习（一）——项目结构及其含义
OEC小胖胖
MyBatismybatis学习web后端

    1.MyBatis简介MyBatis是一款优秀的持久层框架，它通过SQL映射的方式实现Java对数据库操作的映射，既保留了SQL语句的灵活性，也简化了代码的编写。在一个MyBatis项目中，核心部分主要有：配置文件（mybatis-config.xml）映射文件（Mapper.xml）实体类（Entity/POJO）接口类（Mapper接口）MyBatis会话工厂（SqlSessionFactor
    

    • 

  • MyBatis 如何将 Mapper 接口与其 XML 映射文件关联：深入原理与实现
OEC小胖胖
web后端mybatisxmljavaweb后端

    MyBatis如何将Mapper接口与其XML映射文件关联：深入原理与实现1.概述MyBatis是一个简单、灵活的持久层框架，它通过SQL语句将Java对象与数据库进行映射。MyBatis支持基于XML和注解的配置方式。在实际开发中，XML映射文件与Mapper接口的关联是MyBatis的核心功能之一。通过这种关联，开发者可以在Mapper接口中定义方法，并在XML文件中编写SQL语句，从而实现数
    

    • 

  • Mybatis实现员工管理系统
wu1113_
mybatisjavamaven

    文章目录1.案例需求2.编程思路3.案例源码4.小结1.案例需求在上次做的父子模块的maven以及Ajax实现人工管理系统的基础上使用Mybatis实现员工管理系统的增删改查，具体运行效果如下：2.编程思路Mybatis框架的一般执行流程：创建MyBatis配置文件mybatis-config.xml在里面加载数据源、事务等，管理映射文件创建需要的映射文件mapper.xml，用于映射表中列和实体
    

    • 

  • springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么
okchan666
springbootjava

    先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
    

    • 

  • MyBatis 方法重载的陷阱及解决方案
molashaonian
mybatis方法重载异常方法名相同

    在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
    

    • 

  • Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码 及 功能清单
Xiaohong0716
mybatisjavaspringcloud

    一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
    

    • 

  • BindingException: Invalid bound statement (not found)
小卡车555
MyBatismybatisjavamysql

    Mybatis出现绑定异常问题的解决org.apache.ibatis.binding.BindingException:Invalidboundstatement(notfound)一般的原因是Mapperinterface和xml文件的定义对应不上，需要检查包名，namespace，函数名称等能否对应上，需要比较细致的对比，我经常就是写错了一两个字母搞的很长时间找不到错误按以下步骤一一执行：1
    

    • 

  • 工程项目管理系统源码与Spring Cloud：实现高效系统管理与二次开发
微服务技术分享
springcloudjava工程项目管理系统源码

    随着企业规模的不断扩大和业务的快速发展，传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性，企业需要借助先进的数字化技术进行转型。本文将介绍一款采用SpringCloud+SpringBoot+Mybatis技术框架的工程项目管理系统，该系统涵盖了项目管理、合同管理、预警管理、竣工管理、质量管理等多个方面，通过数据字典、编码管理、用户管理
    

    • 

  • [附源码]SSM计算机毕业设计游戏账号交易平台JAVA
计算机程序源码
java游戏mysql

    项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
    

    • 

  • Mybatis Mysql
莫夏_b560

    1、查询失败或者结果异常andfwbdh=#{fwbdh}更换成andfwbdh=#{fwbdh}
    

    • 

  • 33. MyBatis中的@Param注解如何使用？如何在Mapper接口中传递多个参数？
这孩子叫逆
Mybatis笔记javamybatistomcat

    在MyBatis中，@Param注解用于将方法参数绑定到SQL语句中的命名参数。它主要用于在Mapper接口中传递多个参数，以便在SQL语句中更方便地引用这些参数。为什么使用@Param注解？在MyBatis中，当Mapper接口的方法只有一个参数时，MyBatis会默认将这个参数的名称绑定为#{parameter}，可以直接在SQL语句中引用它。如果方法有多个参数，MyBatis默认使用para
    

    • 

  • Python+Django毕业设计校园易购二手交易平台（程序+LW+部署）
Python、JAVA毕设程序源码
课程设计javamysql

    项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
    

    • 

  • Springboot3 整合 Mybatis3
（前程似锦）
mybatisjavaspringboot

    Springboot3整合MybatisSpringboot3整合MybatisSpringboot3整合Mybatis一、导入依赖二、编写配置文件三、定义模型entity实体类四、在启动类上添加注解，表示mapper接口所在位置五、定义mapper接口六、定义mapper.xml映射文件七、service层八、测试一、导入依赖mybatis的必要依赖注意：使用springboot3的话要使用my
    

    • 

  • mybatis支持json，Spring boot配置
Knight_9

    mysql5.7版本以后支持原生json格式，基于Springboot进行配置说明。mybatis支持mysql的json格式mysql-connector，mysql的驱动版本要大于等于5.1.40，否则json字段查询会发生乱码。继承BaseTypeHandler自定义一个json类型处理器，放到一个handler包下，例：packagecom.c.config.handler;importc
    

    • 

  • 【Java】Mybatis Druid连接池配置详细
beautiful_huang
Java

    pom.xmlcom.alibabadruid1.0.18.propertiesspring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.url=jdbc:mysql://localhost:3306/mybatis2?characterEncoding=utf-8&useSSL=truespring.da
    

    • 

  • 关于com.baomidou:mybatis-plus-boot-starter:jar:unknown was not found解决办法
波斯CD
mybatisjarjava

    原型com.baomidoumybatis-plus-boot-starter修改以后解决了com.baomidoumybatis-plus-boot-starter3.5.3.1
    

    • 

  • MyBatis-Plus 3.5.5的代码生成器 实践【完整代码】
qq_43513957
mybatis

    MyBatis-Plus3.5.5的代码生成器实践【完整代码】1.表：要有一个version字段，乐观锁更新。配置拦截器的代码packagecom.example.demo.zmybatisplusGenerator.config;importcom.baomidou.mybatisplus.annotation.DbType;importcom.baomidou.mybatisplus.exte
    

    • 

  • 深入解析 MyBatis：从理论到项目实例
OEC小胖胖
web后端mybatisjavaspringweb后端

    深入解析MyBatis：从理论到项目实例目录MyBatis概述MyBatis项目结构及作用核心概念详解分页功能的实现与深入剖析动态SQL缓存机制详解与Spring集成常见问题与深入分析完整项目示例总结1.MyBatis概述MyBatis是一个轻量级的持久层框架，使用SQL查询语句来访问数据库。它与Java对象建立映射关系，通过配置文件或注解来管理SQL语句，灵活性高且与数据库操作直接相关，适合需要
    

    • 

  • MyBatis Plus 实战详解
Aries263
redis分布式数据库

    一、引言MyBatisPlus（简称MP）是MyBatis的增强工具，旨在简化开发、提高效率。它保留了MyBatis的强大功能，并在其基础上进行了扩展和优化，提供了强大的CRUD操作、配置选项、条件构造器等功能。本文将详细介绍MyBatisPlus的安装、配置、基本操作以及分页和条件查询的使用。二、安装与配置1.添加依赖首先，在Maven项目的pom.xml中添加MyBatisPlus的依赖。以下
    

    • 

  • 在springboot中，利用xml配置mybatis的方法
猪猡猪猡猪
javamybatismybatisspringbootxmljavamysql

    前置步骤参考博客：SpringBoot配置Mybatis的两种方式（通过XML配置和通过YML配置文件配置）_Darreni的博客-CSDN博客但按照博客中的关键代码和步骤创建的项目无法启动启动报错：Description:FailedtoconfigureaDataSource:'url’attributeisnotspecif:Reason:Failedtodetermineasuitable
    

    • 

  • MyBatis 学习笔记(4) 动态SQL
张云飞Vir

    1.背景本节讲mybatis应对动态SQL的场景。2.知识动态SQL是指“条件"不固定的SQL，对比于一般的SQL，动态SQL会有一个或者多个条件/参数。比如：场景：查询的时候，如果用户输入了姓名，就按姓名模糊查询；同时又输入了邮箱，就再增加一个条件按姓名+邮箱两个条件查询。传统的拼接SQL很费力，拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。借助功能强大的基于OGNL的
    

    • 

  • 解线性方程组
qiuwanchi

    package gaodai.matrix;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
Scanner scanner = new Sc
    

    • 

  • 在mysql内部存储代码
annan211
性能mysql存储过程触发器

    
在mysql内部存储代码
在mysql内部存储代码，既有优点也有缺点，而且有人倡导有人反对。
先看优点：
1 她在服务器内部执行，离数据最近，另外在服务器上执行还可以节省带宽和网络延迟。
2 这是一种代码重用。可以方便的统一业务规则，保证某些行为的一致性，所以也可以提供一定的安全性。
3 可以简化代码的维护和版本更新。
4 可以帮助提升安全，比如提供更细
    

    • 

  • Android使用Asynchronous Http Client完成登录保存cookie的问题
hotsunshine
android

    Asynchronous Http Client是android中非常好的异步请求工具
除了异步之外还有很多封装比如json的处理，cookie的处理
引用
Persistent Cookie Storage with PersistentCookieStore
This library also includes a PersistentCookieStore whi
    

    • 

  • java面试题
Array_06
java面试

    java面试题
第一，谈谈final, finally, finalize的区别。
final-修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能
    

    • 

  • 网站加速
oloz
网站加速

    前序:本人菜鸟，此文研究总结来源于互联网上的资料，大牛请勿喷！本人虚心学习，多指教.
1、减小网页体积的大小，尽量采用div+css模式，尽量避免复杂的页面结构，能简约就简约。
2、采用Gzip对网页进行压缩；
   GZIP最早由Jean-loup Gailly和Mark Adler创建，用于UNⅨ系统的文件压缩。我们在Linux中经常会用到后缀为.gz
    

    • 

  • 正确书写单例模式
随意而生
java 设计模式 单例

    　　单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了吧。但是其中的坑却不少，所以也常作为面试题来考。本文主要对几种单例写法的整理，并分析其优缺点。很多都是一些老生常谈的问题，但如果你不知道如何创建一个线程安全的单例，不知道什么是双检锁，那这篇文章可能会帮助到你。
　　懒汉式，线程不安全
　　当被问到要实现一个单例模式时，很多人的第一反应是写出如下的代码，包括教科书上也是这样
    

    • 

  • 单例模式
香水浓
java

    懒汉  调用getInstance方法时实例化
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static synchronized Singleton getInstance() {
if(null == ins
    

    • 

  • 安装Apache问题：系统找不到指定的文件 No installed service named "Apache2"
AdyZhang
apachehttp server

    安装Apache问题：系统找不到指定的文件 No installed service named "Apache2"
每次到这一步都很小心防它的端口冲突问题，结果，特意留出来的80端口就是不能用，烦。
解决方法确保几处：
1、停止IIS启动
2、把端口80改成其它 （譬如90，800，，，什么数字都好）
3、防火墙(关掉试试)
在运行处输入 cmd 回车，转到apa
    

    • 

  • 如何在android 文件选择器中选择多个图片或者视频？
aijuans
android

    我的android app有这样的需求，在进行照片和视频上传的时候，需要一次性的从照片/视频库选择多条进行上传
但是android原生态的sdk中，只能一个一个的进行选择和上传。
我想知道是否有其他的android上传库可以解决这个问题，提供一个多选的功能，可以使checkbox之类的，一次选择多个 处理方法
官方的图片选择器(但是不支持所有版本的androi，只支持API Level 
    

    • 

  • mysql中查询生日提醒的日期相关的sql
baalwolf
mysql

    SELECT sysid,user_name,birthday,listid,userhead_50,CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')),CURDATE(),  dayofyear( CONCAT(YEAR(CURDATE()),DATE_FORMAT(birthday,'-%m-%d')))-dayofyear(
    

    • 

  • MongoDB索引文件破坏后导致查询错误的问题
BigBird2012
mongodb

    问题描述：
MongoDB在非正常情况下关闭时，可能会导致索引文件破坏，造成数据在更新时没有反映到索引上。
解决方案：
 
使用脚本，重建MongoDB所有表的索引。
var names = db.getCollectionNames();
for( var i in names ){
var name = names[i];
print(name); 
    

    • 

  • Javascript Promise
bijian1013
JavaScriptPromise

            Parse JavaScript SDK现在提供了支持大多数异步方法的兼容jquery的Promises模式，那么这意味着什么呢，读完下文你就了解了。
一.认识Promises
        “Promises”代表着在javascript程序里下一个伟大的范式，但是理解他们为什么如此伟大不是件简
    

    • 

  • [Zookeeper学习笔记九]Zookeeper源代码分析之Zookeeper构造过程
bit1129
zookeeper

       Zookeeper重载了几个构造函数，其中构造者可以提供参数最多，可定制性最多的构造函数是  
 
public ZooKeeper(String connectString, int sessionTimeout, Watcher watcher, long sessionId, byte[] sessionPasswd, boolea
    

    • 

  • 【Java命令三】jstack
bit1129
jstack

    jstack是用于获得当前运行的Java程序所有的线程的运行情况(thread dump），不同于jmap用于获得memory dump
 
[hadoop@hadoop sbin]$ jstack
Usage:
jstack [-l] <pid>
(to connect to running process)
jstack -F 
    

    • 

  • jboss 5.1启停脚本　动静分离部署
ronin47

    以前启动jboss，往各种xml配置文件，现只要运行一句脚本即可。start nohup sh /**/run.sh -c servicename  -b ip -g  clustername   -u broatcast jboss.messaging.ServerPeerID=int  -Djboss.service.binding.set=p
    

    • 

  • UI之如何打磨设计能力?
brotherlamp
UIui教程ui自学ui资料ui视频

     
在越来越拥挤的初创企业世界里，视觉设计的重要性往往可以与杀手级用户体验比肩。在许多情况下，尤其对于 Web 初创企业而言，这两者都是不可或缺的。前不久我们在《右脑革命：别学编程了，学艺术吧》中也曾发出过重视设计的呼吁。如何才能提高初创企业的设计能力呢?以下是 9 位创始人的体会。
1.找到自己的方式
如果你是设计师，要想提高技能可以去设计博客和展示好设计的网站如D-lists或
    

    • 

  • 三色旗算法
bylijinnan
java算法

    
import java.util.Arrays;
/**
问题：
假设有一条绳子，上面有红、白、蓝三种颜色的旗子，起初绳子上的旗子颜色并没有顺序，
您希望将之分类，并排列为蓝、白、红的顺序，要如何移动次数才会最少，注意您只能在绳
子上进行这个动作，而且一次只能调换两个旗子。
网上的解法大多类似：
在一条绳子上移动，在程式中也就意味只能使用一个阵列，而不使用其它的阵列来
    

    • 

  • 警告:No configuration found for the specified action: \'s
chiangfai
configuration

    1.index.jsp页面form标签未指定namespace属性。
<!--index.jsp代码-->
<%@taglib prefix="s" uri="/struts-tags"%>
...
<s:form action="submit" method="post"&g
    

    • 

  • redis -- hash_max_zipmap_entries设置过大有问题
chenchao051
redishash

    使用redis时为了使用hash追求更高的内存使用率，我们一般都用hash结构，并且有时候会把hash_max_zipmap_entries这个值设置的很大，很多资料也推荐设置到1000，默认设置为了512，但是这里有个坑
 
#define ZIPMAP_BIGLEN 254
#define ZIPMAP_END 255
 
 
/* Return th
    

    • 

  • select into outfile access deny问题
daizj
mysqltxt导出数据到文件

    本文转自：http://hatemysql.com/2010/06/29/select-into-outfile-access-deny%E9%97%AE%E9%A2%98/
为应用建立了rnd的帐号，专门为他们查询线上数据库用的，当然，只有他们上了生产网络以后才能连上数据库，安全方面我们还是很注意的，呵呵。
授权的语句如下：
grant select on armory.* to rn
    

    • 

  • phpexcel导出excel表简单入门示例
dcj3sjt126com
PHPExcelphpexcel

    
<?php
error_reporting(E_ALL);
ini_set('display_errors', TRUE);
ini_set('display_startup_errors', TRUE);
 
if (PHP_SAPI == 'cli')
die('This example should only be run from a Web Brows
    

    • 

  • 美国电影超短200句
dcj3sjt126com
电影

    1. I see． 我明白了。2. I quit! 我不干了!3. Let go! 放手!4. Me too． 我也是。5. My god! 天哪!6. No way! 不行!7. Come on． 来吧(赶快)8. Hold on． 等一等。9. I agree。 我同意。10. Not bad． 还不错。11. Not yet． 还没。12. See you． 再见。13. Shut up! 
    

    • 

  • Java访问远程服务
dyy_gusi
httpclientwebservicegetpost

        随着webService的崛起，我们开始中会越来越多的使用到访问远程webService服务。当然对于不同的webService框架一般都有自己的client包供使用，但是如果使用webService框架自己的client包，那么必然需要在自己的代码中引入它的包，如果同时调运了多个不同框架的webService，那么就需要同时引入多个不同的clien
    

    • 

  • Maven的settings.xml配置
geeksun
settings.xml

    settings.xml是Maven的配置文件，下面解释一下其中的配置含义：
settings.xml存在于两个地方：
1.安装的地方：$M2_HOME/conf/settings.xml
2.用户的目录：${user.home}/.m2/settings.xml
前者又被叫做全局配置，后者被称为用户配置。如果两者都存在，它们的内容将被合并，并且用户范围的settings.xml优先。

    

    • 

  • ubuntu的init与系统服务设置
hongtoushizi
ubuntu

    转载自： 
http://iysm.net/?p=178 init
Init是位于/sbin/init的一个程序，它是在linux下，在系统启动过程中，初始化所有的设备驱动程序和数据结构等之后，由内核启动的一个用户级程序，并由此init程序进而完成系统的启动过程。
ubuntu与传统的linux略有不同，使用upstart完成系统的启动，但表面上仍维持init程序的形式。
运行
    

    • 

  • 跟我学Nginx+Lua开发目录贴
jinnianshilongnian
nginxlua

    使用Nginx+Lua开发近一年的时间，学习和实践了一些Nginx+Lua开发的架构，为了让更多人使用Nginx+Lua架构开发，利用春节期间总结了一份基本的学习教程，希望对大家有用。也欢迎谈探讨学习一些经验。 
  目录
第一章 安装Nginx+Lua开发环境
第二章 Nginx+Lua开发入门
第三章 Redis/SSDB+Twemproxy安装与使用
第四章 L
    

    • 

  • php位运算符注意事项
home198979
位运算PHP&

    $a = $b = $c = 0;
$a & $b = 1;
$b | $c = 1
 问a,b,c最终为多少?
 
当看到这题时，我犯了一个低级错误，误 以为位运算符会改变变量的值。所以得出结果是1 1 0
但是位运算符是不会改变变量的值的，例如：
$a=1;$b=2;
$a&$b;
 这样a,b的值不会有任何改变

    

    • 

  • Linux shell数组建立和使用技巧
pda158
linux

    1.数组定义 　　[chengmo@centos5 ~]$ a=(1 2 3 4 5) 　　[chengmo@centos5 ~]$ echo $a 　　1 　　一对括号表示是数组，数组元素用“空格”符号分割开。 　　
2.数组读取与赋值 　　得到长度： 　　[chengmo@centos5 ~]$ echo ${#a[@]} 　　5 　　用${#数组名[@或
    

    • 

  • hotspot源码(JDK7)
ol_beta
javaHotSpotjvm

    源码结构图，方便理解：
 
├─agent                            Serviceab
    

    • 

  • Oracle基本事务和ForAll执行批量DML练习
vipbooks
oraclesql

    基本事务的使用：
从账户一的余额中转100到账户二的余额中去，如果账户二不存在或账户一中的余额不足100则整笔交易回滚
select * from account;
-- 创建一张账户表
create table account(
-- 账户ID
id number(3) not null,
-- 账户名称
nam
    

    •