CodeBoy975
CodeBoy975

MyBatis—— SQL执行流程

一、SQL执行流程

我们通常都会先调用 SqlSession 接口的 getMapper方法为我们的Mapper接口生成实现类。然后就可以通过Mapper进行数据库操作。 比如像下面这样:

ArticleMapper articleMapper = session.getMapper(ArticleMapper.class); 
Article article = articleMapper.findOne(1);

如果大家对 MyBatis 较为了解，会知道 SqlSession 是通过 JDK 动态代理的方式为接口 生成代理对象的。在调用接口方法时，相关调用会被代理逻辑拦截。在代理逻辑中可根据方 法名及方法归属接口获取到当前方法对应的 SQL 以及其他一些信息，拿到这些信息即可进 行数据库操作。

1. 为Mapper接口创建代理对象

// -☆- DefaultSqlSession
 public  T getMapper(Class type) {
    return configuration.getMapper(type, this);
  }
// -☆- Configuration
public  T getMapper(Class type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
 }

// -☆- MapperRegistry
  public  T getMapper(Class type, SqlSession sqlSession) {
  // 从 knownMappers 中获取与 type 对应的 MapperProxyFactory
    final MapperProxyFactory mapperProxyFactory = (MapperProxyFactory) knownMappers.get(type);
    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 接口代理对象的创建逻辑初现端倪。MyBatis 在解析配置文件的节点的过程中，会调用 MapperRegistry 的 addMapper 方法将 Class 到 MapperProxyFactory 对象的映射关系存入到 knownMappers。

在获取到 MapperProxyFactory 对象后，即可调用工厂方法为 Mapper 接口生成代理对象 了。相关逻辑如下:

// -☆- MapperProxyFactory
 public T newInstance(SqlSession sqlSession) {
    // 创建 MapperProxy 对象，MapperProxy 实现了 InvocationHandler 接口， 
    // 代理逻辑封装在此类中
    final MapperProxy mapperProxy = new MapperProxy(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

 protected T newInstance(MapperProxy mapperProxy) {
    // 通过 JDK 动态代理创建代理对象
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

上面代码首先创建了一个MapperProxy对象，该对象实现InvocationHandler接口。然后将对象作为参数传给重载方法，并在重载方法中调用JDK动态代理接口为Mapper生成代理对象。

代理对象已经创建完毕，下面就可以调用接口方法进行数据库操作了。由于接口 方法会被代理逻辑拦截，所以下面我们把目光聚焦在代理逻辑上面，看看代理逻辑会做哪些 事情。

2.执行代理逻辑

Mapper接口方法的代理逻辑首先会对拦截的方法进行一些检测，来决定是否执行后续的数据库操作。

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        // 如果方法是定义在 Object 类中的，则直接调用
        if (Object.class.equals(method.getDeclaringClass())) {
            return method.invoke(this, args);
            
        /*
         * 下面的代码最早出现在 mybatis-3.4.2 版本中，用于支持 JDK 1.8 中的
         * 新特性 - 默认方法。这段代码的逻辑就不分析了，有兴趣的同学可以
         * 去 Github 上看一下相关的相关的讨论（issue #709），链接如下：
         * 
         *   https://github.com/mybatis/mybatis-3/issues/709
         */  
        } else if (isDefaultMethod(method)) {
            return invokeDefaultMethod(proxy, method, args);
        }
    } catch (Throwable t) {
        throw ExceptionUtil.unwrapThrowable(t);
    }
    
    // 从缓存中获取 MapperMethod 对象，若缓存未命中，则创建 MapperMethod 对象
    final MapperMethod mapperMethod = cachedMapperMethod(method);
    
    // 调用 execute 方法执行 SQL
    return mapperMethod.execute(sqlSession, args);
}

代理逻辑会首先检测被拦截的方法是不是定义在 Object 中的，比如 equals、hashCode 方法等。对于这类方法，直接执行即可。除此之外，MyBatis 从 3.4.2 版本开始，对 JDK 1.8 接口的默认方法提供了支持，具体就不分析了。完成相关检测后，紧接着从缓存中获取或者创建 MapperMethod 对象，然后通过该对象中的 execute 方法执行 SQL。在分析 execute 方法之前，我们先来看一下 MapperMethod 对象的创建过程。MapperMethod 的创建过程看似普通，但却包含了一些重要的逻辑，所以不能忽视。

3.创建MapperMethod对象

public class MapperMethod {

    private final SqlCommand command;
    private final MethodSignature method;

    public MapperMethod(Class mapperInterface, Method method, Configuration config) {
        // 创建 SqlCommand 对象，该对象包含一些和 SQL 相关的信息
        this.command = new SqlCommand(config, mapperInterface, method);
        // 创建 MethodSignature 对象，从类名中可知，该对象包含了被拦截方法的一些信息
        this.method = new MethodSignature(config, mapperInterface, method);
    }
}

主要是创建 SqlCommand 和 MethodSignature 对象。这两个对象分别记录了不同的信息，这些信息在后续的方法调用中都会被用到。
1、SqlCommand 中保存了一些和 SQL 相关的信息
2、MethodSignature 即方法签名，顾名思义，该类保存了一些和目标方法相关的信息。比如目标方法的返回类型，目标方法的参数列表信息等。

4.执行execute方法

前面已经分析了 MapperMethod 的初始化过程，现在 MapperMethod 创建好了。那么，接下来要做的事情是调用 MapperMethod 的 execute 方法，执行 SQL。代码如下：

public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
     // 根据 SQL 类型执行相应的数据库操作
    switch (command.getType()) {
      case INSERT: {
        // 对用户传人的参数进行转换
    	Object param = method.convertArgsToSqlCommandParam(args);
    	// 执行插入操作，rowCountResult 方法用于处理返回值
        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:
       // 根据目标方法的返回类型进行相应的查询操作
        if (method.returnsVoid() && method.hasResultHandler()) {
          /*
                 * 如果方法返回值为 void，但参数列表中包含 ResultHandler，表明使用者
                 * 想通过 ResultHandler 的方式获取查询结果，而非通过返回值获取结果
                 */
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          // 执行查询操作，并返回多个结果 
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
         // 执行查询操作，并将结果封装在 Map 中返回
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
         // 执行查询操作，并返回一个 Cursor 对象
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
           // 执行查询操作，并返回一个结果
          result = sqlSession.selectOne(command.getName(), param);
        }
        break;
      case FLUSH:
          // 执行刷新操作
        result = sqlSession.flushStatements();
        break;
      default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    // 如果方法的返回值为基本类型，而返回值却为 null，此种情况下应抛出异常
    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;
  }

如上，execute 方法主要由一个 switch 语句组成，用于根据 SQL 类型执行相应的数据库操作。该方法的逻辑清晰。

  // -☆- DefaultSqlSession
 @Override
  public  T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List list = this.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;
    }
  }

selectOne 方法在内部调用 selectList 了方法，并取 selectList 返回值的第 1 个元素 作为自己的返回值。如果 selectList 返回的列表元素大于 1，则抛出异常。

5.获取BoundSql对象

DefaultSqlSession中的selectOne()方法最终也会调用到selectList()方法。它先从数据大管家configuration中根据请求方法的全名称拿到对应的MappedStatement对象，然后调用执行器的查询方法。

//statement是调用方法的全名称，parameter为参数的Map
 @Override
  public  List selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
     //在mapper.xml中每一个SQL节点都会封装为MappedStatement对象
     //在configuration中就可以通过请求方法的全名称获取对应的MappedStatement对象
      MappedStatement ms = configuration.getMappedStatement(statement);
      // 调用 Executor 实现类中的 query 方法
      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();
    }
  }

在configuration这个大管家对象中，保存着mapper.xml里面所有的SQL节点。每一个节点对应一个MappedStatement对象，而动态生成的各种sqlNode保存在SqlSource对象，SqlSource对象有一个方法就是getBoundSql()。
我们先来看一下BoundSql类哪有哪些属性。

public class BoundSql { 
    //动态生成的SQL,解析完毕带有占位性的SQL
    private final String sql;
    //每个参数的信息。比如参数名称、输入/输出类型、对应的JDBC类型等
    private final List parameterMappings;
    //参数
    private final Object parameterObject;
    private final Map additionalParameters;
    private final MetaObject metaParameters;
}

接下来，开始分析 BoundSql 的构建过程。我们源码之 旅的第一站是 MappedStatement 的 getBoundSql 方法，代码如下:

// -☆- MappedStatement
 public BoundSql getBoundSql(Object parameterObject) {
   // 调用 sqlSource 的 getBoundSql 获取 BoundSql
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings == null || parameterMappings.isEmpty()) {
      // 创建新的 BoundSql，这里的 parameterMap 是 ParameterMap 类型。 
      // 由 节点进行配置，该节点已经废弃，不推荐使用。
      // 默认情况下，parameterMap.getParameterMappings() 返回空集合
      boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }

    // check for nested result maps in parameter mappings (issue #30)
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
      String rmId = pm.getResultMapId();
      if (rmId != null) {
        ResultMap rm = configuration.getResultMap(rmId);
        if (rm != null) {
          hasNestedResultMaps |= rm.hasNestedResultMaps();
        }
      }
    }

接下来，我们把目光转 移到 SqlSource 实现类的 getBoundSql 方法上。SqlSource 是一个接口，它有如下几个实现类:

  • DynamicSqlSource
  • RawSqlSource
  • StaticSqlSource
  • ProviderSqlSource
  • VelocitySqlSource

仅前两个实现类会在映射文件解析的过程中被使用。 当 SQL 配置中包含${}(不是#{})占位符，或者包含、等标签时，会被认为是 动态 SQL，此时使用 DynamicSqlSource 存储 SQL 片段。否则，使用 RawSqlSource 存储 SQL 配置信息。相比之下 DynamicSqlSource 存储的 SQL 片段类型较多，解析起来也更为复杂一 些。因此下面我将分析 DynamicSqlSource 的 getBoundSql 方法。弄懂这个，RawSqlSource 也 不在话下。

public class DynamicSqlSource implements SqlSource {
    public BoundSql getBoundSql(Object parameterObject) {
        DynamicContext context = new DynamicContext(configuration, parameterObject);
        //rootSqlNode为sqlNode节点的最外层封装，即MixedSqlNode。
        //解析完所有的sqlNode，将sql内容设置到context
        rootSqlNode.apply(context);
        SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
        Class parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
        // 构建 StaticSqlSource，在此过程中将 sql 语句中的占位符 #{} 替换为占位符，
        // 并为每个占位符构建相应的 ParameterMapping
        SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
        //创建BoundSql对象
        BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
        for (Map.Entry entry : context.getBindings().entrySet()) {
            boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
        }
        return boundSql;
    }
}

对于一个包含了${}占位符，或、等标签的 SQL，在解析的过程中，会被分解 成多个片段。每个片段都有对应的类型，每种类型的片段都有不同的解析逻辑。在源码中， 片段这个概念等价于 sql 节点，即 SqlNode。

动态SQL要根据不同的sqlNode节点，调用对应的apply方法，有的还要通过Ognl表达式来判断是否需要添加当前节点，比如IfSqlNode。

rootSqlNode.apply(context)是一个迭代调用的过程。最后生成的内容保存在DynamicContext对象，比如select * from user WHERE uid=#{uid}。

然后调用SqlSourceBuilder.parse()方法

// -☆- SqlSourceBuilder
public SqlSource parse(String originalSql, Class parameterType,
     Map additionalParameters) { 
     // 创建 #{} 占位符处理器 
     ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(
configuration, parameterType, additionalParameters);
     // 创建 #{} 占位符解析器
     GenericTokenParser parser = new GenericTokenParser("#{", "}", handler); 
     // 解析 #{} 占位符，并返回解析结果
     String sql = parser.parse(originalSql);
     // 封装解析结果到 StaticSqlSource 中，并返回
   return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
}

它主要做了两件事：
1、将SQL语句中的#{}替换为占位符
2、将#{}里面的字段封装成ParameterMapping对象，添加到parameterMappings。

ParameterMapping对象保存的就是参数的类型信息，如果没有配置则为null。
ParameterMapping{property=‘uid’, mode=IN, javaType=class java.lang.Object, jdbcType=null, numericScale=null, resultMapId=‘null’, jdbcTypeName=‘null’, expression=‘null’}

最后返回的BoundSql对象就包含一个带有占位符的SQL和参数的具体信息。

二、执行SQL

创建完BoundSql对象，调用query方法，这里要来说说 executor 变量，该变量类型为 Executor。Executor 是一个接口，它 的实现类如下:
MyBatis—— SQL执行流程_第1张图片
默认情况下，executor 的类型为 CachingExecutor，该类是一 个装饰器类，用于给目标 Executor 增加二级缓存功能。

public class CachingExecutor implements Executor {
    public  List 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) {
                //从缓存中获取数据
                List list = (List) tcm.getObject(cache, key);
                if (list == null) {
                    list = delegate. query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                    tcm.putObject(cache, key, list); // issue #578 and #116
                }
                return list;
            }
        }
        return delegate. query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }
}

接着看query方法，创建PreparedStatement预编译对象，执行SQL并获取返回集合。

public class SimpleExecutor extends BaseExecutor {
    public  List doQuery(MappedStatement ms, Object parameter, 
            RowBounds rowBounds, ResultHandler resultHandler, 
            BoundSql boundSql) throws SQLException {
        Statement stmt = null;
        try {
            Configuration configuration = ms.getConfiguration();
            //获取Statement的类型，即默认的PreparedStatementHandler
            //需要注意，在这里如果配置了插件，则StatementHandler可能返回的是一个代理
            StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            //创建PreparedStatement对象，并设置参数值
            stmt = prepareStatement(handler, ms.getStatementLog());
            //执行execute 并返回结果集
            return handler.query(stmt, resultHandler);
        } finally {
            closeStatement(stmt);
        }
    }
}

prepareStatement方法获取数据库连接并构建Statement对象设置SQL参数。

1. 创建StatementHandler

在 MyBatis 的源码中，StatementHandler 是一个非常核心接口。之所以说它核心，是因 为从代码分层的角度来说，StatementHandler 是 MyBatis 源码的边界，再往下层就是 JDBC 层 面的接口了。StatementHandler 需要和 JDBC 层面的接口打交道，它要做的事情有很多。在 执行 SQL 之前，StatementHandler 需要创建合适的 Statement 对象，然后填充参数值到 Statement 对象中，最后通过 Statement 对象执行 SQL。
MyBatis—— SQL执行流程_第2张图片

2. 创建PreparedStatement

JDBC 提供了三种 Statement 接口，分别是 Statement、PreparedStatement 和
CallableStatement。他们的关系如下:
MyBatis—— SQL执行流程_第3张图片
上面三个接口的层级分明，其中 Statement 接口提供了执行 SQL，获取执行结果等基本 功能。PreparedStatement 在此基础上，对 IN 类型的参数提供了支持。使得我们可以使用运 行时参数替换 SQL 中的问号?占位符，而不用手动拼接 SQL。CallableStatement 则是在 PreparedStatement 基础上，对 OUT 类型的参数提供了支持，该种类型的参数用于保存存储 过程输出的结果。

public class SimpleExecutor extends BaseExecutor {
    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        Statement stmt;
        // 获取数据库连接
        C onnection connection = getConnection(statementLog);
        // 创建 Statement，
        stmt = handler.prepare(connection, transaction.getTimeout()); 
        // 为 Statement 设置 IN 参数
        handler.parameterize(stmt);
        return stmt;
     }
}

上面代码的逻辑比较简单，总共包含三个步骤。如下:

  1. 获取数据库连接
  2. 创建 Statement
  3. 为 Statement 设置 IN 参数

获取Connection连接
我们看到getConnection方法就是获取Connection连接的地方。但这个Connection也是一个代理对象，它的调用程序处理器为ConnectionLogger。显然，它是为了更方便的打印日志。

public abstract class BaseExecutor implements Executor {
    protected Connection getConnection(Log statementLog) throws SQLException {
        //从c3p0连接池中获取一个连接
        Connection connection = transaction.getConnection();
        //如果日志级别为Debug，则为这个连接生成代理对象返回
        //它的处理类为ConnectionLogger
        if (statementLog.isDebugEnabled()) {
            return ConnectionLogger.newInstance(connection, statementLog, queryStack);
        } else {
            return connection;
        }
    }
}

MyBatis 并未没有在 getConnection 方法中直接调用 JDBC DriverManager 的 getConnection 方 法获取获取连接，而是通过数据源获取连接。MyBatis 提供了两种基于 JDBC 接口的数据源， 分别为 PooledDataSource 和 UnpooledDataSource。创建或获取数据库连接的操作最终是由这 两个数据源执行。
执行预编译

public class PreparedStatementHandler
    protected Statement instantiateStatement(Connection connection) throws SQLException {
        String sql = boundSql.getSql();
        return connection.prepareStatement(sql);
    }
}

所以，在执行的onnection.prepareStatement(sql)的时候，实际调用的是ConnectionLogger类的invoke()。

public final class ConnectionLogger extends BaseJdbcLogger implements InvocationHandler {

    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]), true);
                }        
                //调用connection.prepareStatement
                PreparedStatement stmt = (PreparedStatement) method.invoke(connection, params);
                //又为stmt创建了代理对象，通知类为PreparedStatementLogger
                stmt = PreparedStatementLogger.newInstance(stmt, statementLog, queryStack);
                return stmt;
            }
        } 
    }
}

public static PreparedStatement newInstance(PreparedStatement stmt, Log statementLog, int queryStack) {
    InvocationHandler handler = new PreparedStatementLogger(stmt, statementLog, queryStack);
    ClassLoader cl = PreparedStatement.class.getClassLoader();
    return (PreparedStatement) Proxy.newProxyInstance(cl, 
            new Class[]{PreparedStatement.class, CallableStatement.class}, handler);
}

最后返回的PreparedStatement又是个代理对象。

3. #{}占位符的解析与参数的设置过程

假设我们有这样一条 SQL 语句:

SELECT * FROM author WHERE name = #{name} AND age = #{age}

这个 SQL 语句中包含两个#{}占位符，在运行时这两个占位符会被解析成两个 ParameterMapping 对象。如下:

ParameterMapping{property='name', mode=IN, javaType=class java.lang.String, jdbcType=null, ...}

和

ParameterMapping{property='age', mode=IN, javaType=class java.lang.Integer, jdbcType=null, ...}

#{xxx}占位符解析完毕后，得到的 SQL 如下:

SELECT * FROM Author WHERE name = ? AND age = ?

这里假设下面这个方法与上面的 SQL 对应:

Author findByNameAndAge(@Param("name")String name, @Param("age")Integer age)

该方法的参数列表会被 ParamNameResolver 解析成一个 map，如下:

{
   0: "name",
   1: "age"
}

假设该方法在运行时有如下的调用:

findByNameAndAge("tianxiaobo", 20)

此时，需要再次借助 ParamNameResolver 的力量。这次我们将参数名和运行时的参数
值绑定起来，得到如下的映射关系。

{
    "name": "tianxiaobo",
     "age": 20,
    "param1": "tianxiaobo", 
    "param2": 20
}

下一步，我们要将运行时参数设置到 SQL 中。由于原 SQL 经过解析后，占位符信息已 经被擦除掉了，我们无法直接将运行时参数 SQL 中。不过好在，这些占位符信息被记录在 了 ParameterMapping 中了，MyBatis 会将 ParameterMapping 会按照#{}占位符的解析顺序存 入到List中。这样我们通过ParameterMapping在列表中的位置确定它与SQL中的哪一个个? 占位符相关联。同时通过 ParameterMapping 中的 property 字段，我们可以到“参数名与参数 值”映射表中查找具体的参数值。这样，我们就可以将参数值准确的设置到 SQL 中了，此时 SQL 如下:

   SELECT * FROM Author WHERE name = "tianxiaobo" AND age = 20

4. 处理查询结果

MyBatis 可以将查询结果，即结果集 ResultSet 自动映射成实体类对象。这样使用者就无 需再手动操作结果集，并将数据填充到实体类对象中。这可大大降低开发的工作量，提高工 作效率。在 MyBatis 中，结果集的处理工作由结果集处理器 ResultSetHandler 执行。 ResultSetHandler 是一个接口，它只有一个实现类 DefaultResultSetHandler。结果集的处理入 口方法是 handleResultSets，下面来看一下该方法的实现。

public class DefaultResultSetHandler implements ResultSetHandler {
    public List handleResultSets(Statement stmt) throws SQLException {
        final List multipleResults = new ArrayList();
        int resultSetCount = 0;
        //将ResultSet封装成ResultSetWrapper对象
        ResultSetWrapper rsw = getFirstResultSet(stmt);
        //返回mapper.xml中配置的rsultMap 实际上我们没有配置，但会有默认的一个
        List resultMaps = mappedStatement.getResultMaps();
        int resultMapCount = resultMaps.size();
        //处理数据库的返回值，最后加入到multipleResults
        while (rsw != null && resultMapCount > resultSetCount) {
            ResultMap resultMap = resultMaps.get(resultSetCount);
            handleResultSet(rsw, resultMap, multipleResults, null);
            resultSetCount++;
        }
        //返回
        return collapseSingleResultList(multipleResults);
    }
}
 
  
三、总结
 
  
关于Mybatis执行方法的整个过程，我们简单归纳一下。
 
  
     
   
  1. 获取SqlSession，根据方法的返回值类型调用不同的方法。比如selectOne。
    2.  
   
  2. 获取BoundSql对象，根据传递的参数生成SQL语句
    3.  
   
  3. 从数据库连接池获取Connection对象，并为它创建代理，以便打印日志
    4.  
   
  4. 从Connection中获取PreparedStatement预编译对象，并为它创建代理
    5.  
   
  5. 预编译SQL，并设置参数
    6.  
   
  6. 执行、返回数据集合
    7.  
   
  7. 将数据集转换为Java对象
    8.  
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(MyBatis,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的
    
                    
    • 
                                
  • 关于旗正规则引擎下载页面需要弹窗保存到本地目录的问题
                                    何必如此
jsp超链接文件下载窗口
                                    
    生成下载页面是需要选择“录入提交页面”，生成之后默认的下载页面<a>标签超链接为：<a href="<%=root_stimage%>stimage/image.jsp?filename=<%=strfile234%>&attachname=<%=java.net.URLEncoder.encode(file234filesourc
    
                                
    • 
                                
  • 【Spark九十八】Standalone Cluster Mode下的资源调度源代码分析
                                    bit1129
cluster
                                    
    在分析源代码之前，首先对Standalone Cluster Mode的资源调度有一个基本的认识： 
首先，运行一个Application需要Driver进程和一组Executor进程。在Standalone Cluster Mode下，Driver和Executor都是在Master的监护下给Worker发消息创建(Driver进程和Executor进程都需要分配内存和CPU，这就需要Maste
    
                                
    • 
                                
  • linux上独立安装部署spark
                                    daizj
linux安装spark1.4部署
                                    
    下面讲一下linux上安装spark，以 Standalone Mode 安装 
  
1）首先安装JDK 
  
下载JDK：jdk-7u79-linux-x64.tar.gz  ，版本是1.7以上都行，解压 tar -zxvf jdk-7u79-linux-x64.tar.gz   
  
然后配置 ~/.bashrc&nb
    
                                
    • 
                                
  • Java 字节码之解析一
                                    周凡杨
java字节码javap
                                    
      
         
  
一：  Java  字节代码的组织形式    
  
类文件 {  
     OxCAFEBABE ，小版本号，大版本号，常量池大小，常量池数组，访问控制标记，当前类信息，父类信息，实现的接口个数，实现的接口信息数组，域个数，域信息数组，方法个数，方法信息数组，属性个数，属性信息数组  
}  
&nbs
    
                                
    • 
                                
  • java各种小工具代码
                                    g21121
java
                                    
    1.数组转换成List 
import java.util.Arrays;

Arrays.asList(Object[] obj); 2.判断一个String型是否有值 
import org.springframework.util.StringUtils;

if (StringUtils.hasText(str)) 3.判断一个List是否有值 
import org.spring
    
                                
    • 
                                
  • 加快FineReport报表设计的几个心得体会
                                    老A不折腾
finereport
                                    
    一、从远程服务器大批量取数进行表样设计时，最好按“列顺序”取一个“空的SQL语句”，这样可提高设计速度。否则每次设计时模板均要从远程读取数据，速度相当慢！！ 
二、找一个富文本编辑软件（如NOTEPAD+）编辑SQL语句，这样会很好地检查语法。有时候带参数较多检查语法复杂时，结合FineReport中生成的日志，再找一个第三方数据库访问软件（如PL/SQL）进行数据检索，可以很快定位语法错误。 

    
                                
    • 
                                
  • mysql linux启动与停止
                                    墙头上一根草

                                    
    如何启动/停止/重启MySQL一、启动方式1、使用 service 启动：service mysqld start2、使用 mysqld 脚本启动：/etc/inint.d/mysqld start3、使用 safe_mysqld 启动：safe_mysqld&二、停止1、使用 service 启动：service mysqld stop2、使用 mysqld 脚本启动：/etc/inin
    
                                
    • 
                                
  • Spring中事务管理浅谈
                                    aijuans
spring事务管理
                                    
       
Spring中事务管理浅谈  
By Tony Jiang@2012-1-20 Spring中对事务的声明式管理 
拿一个XML举例    
[html]  
view plain 
copy 
print 
?    
 
 <?xml version="1.0" encoding="UTF-8"?>&nb
    
                                
    • 
                                
  • php中隐形字符65279（utf-8的BOM头）问题
                                    alxw4616

                                    
    php中隐形字符65279（utf-8的BOM头）问题 
今天遇到一个问题. php输出JSON 前端在解析时发生问题:parsererror. 
  
调试: 
1.仔细对比字符串发现字符串拼写正确.怀疑是 非打印字符的问题. 
2.逐一将字符串还原为unicode编码. 发现在字符串头的位置出现了一个 65279的非打印字符. 
  
     
    
                                
    • 
                                
  • 调用对象是否需要传递对象(初学者一定要注意这个问题)
                                    百合不是茶
对象的传递与调用技巧
                                    
      
  
类和对象的简单的复习,在做项目的过程中有时候不知道怎样来调用类创建的对象,简单的几个类可以看清楚,一般在项目中创建十几个类往往就不知道怎么来看 
  
为了以后能够看清楚,现在来回顾一下类和对象的创建,对象的调用和传递(前面写过一篇) 
  
类和对象的基础概念: 
  
JAVA中万事万物都是类 类有字段(属性),方法,嵌套类和嵌套接
    
                                
    • 
                                
  • JDK1.5 AtomicLong实例
                                    bijian1013
javathreadjava多线程AtomicLong
                                    
    JDK1.5 AtomicLong实例 
类 AtomicLong 
可以用原子方式更新的 long 值。有关原子变量属性的描述，请参阅 java.util.concurrent.atomic 包规范。AtomicLong 可用在应用程序中（如以原子方式增加的序列号），并且不能用于替换 Long。但是，此类确实扩展了 Number，允许那些处理基于数字类的工具和实用工具进行统一访问。 
 
    
                                
    • 
                                
  • 自定义的RPC的Java实现
                                    bijian1013
javarpc
                                    
            网上看到纯java实现的RPC，很不错。 
        RPC的全名Remote Process Call，即远程过程调用。使用RPC，可以像使用本地的程序一样使用远程服务器上的程序。下面是一个简单的RPC 调用实例，从中可以看到RPC如何
    
                                
    • 
                                
  • 【RPC框架Hessian一】Hessian RPC Hello World
                                    bit1129
Hello world
                                    
    什么是Hessian 
The Hessian binary web service protocol makes web services usable without requiring a large framework, and without learning yet another alphabet soup of protocols. Because it is a binary p
    
                                
    • 
                                
  • 【Spark九十五】Spark Shell操作Spark SQL
                                    bit1129
shell
                                    
    在Spark Shell上，通过创建HiveContext可以直接进行Hive操作 
  
1. 操作Hive中已存在的表 
  
[hadoop@hadoop bin]$ ./spark-shell
Spark assembly has been built with Hive, including Datanucleus jars on classpath
Welcom
    
                                
    • 
                                
  • F5　往header加入客户端的ip
                                    ronin47

                                    
    when HTTP_RESPONSE {if {[HTTP::is_redirect]}{         HTTP::header replace Location [string map {:port/ /} [HTTP::header value Location]]HTTP::header replace Lo
    
                                
    • 
                                
  • java-61-在数组中，数字减去它右边(注意是右边)的数字得到一个数对之差. 求所有数对之差的最大值。例如在数组{2, 4, 1, 16, 7, 5,
                                    bylijinnan
java
                                    
    思路来自： 
http://zhedahht.blog.163.com/blog/static/2541117420116135376632/ 
写了个java版的 
 
 


public class GreatestLeftRightDiff {

	/**
	 * Q61.在数组中，数字减去它右边(注意是右边)的数字得到一个数对之差。
	 * 求所有数对之差的最大值。例如在数组
    
                                
    • 
                                
  • mongoDB 索引
                                    开窍的石头
mongoDB索引
                                    
    在这一节中我们讲讲在mongo中如何创建索引 
      得到当前查询的索引信息 
     db.user.find(_id:12).explain(); 
       cursor: basicCoursor 指的是没有索引 
 &
    
                                
    • 
                                
  • [硬件和系统]迎峰度夏
                                    comsci
系统
                                    
      从这几天的气温来看，今年夏天的高温天气可能会维持在一个比较长的时间内 
 
   所以，从现在开始准备渡过炎热的夏天。。。。 
 
   每间房屋要有一个落地电风扇，一个空调(空调的功率和房间的面积有密切的关系) 
   坐的，躺的地方要有凉垫，床上要有凉席 
   
   电脑的机箱
    
                                
    • 
                                
  • 基于ThinkPHP开发的公司官网
                                    cuiyadll
行业系统
                                    
    后端基于ThinkPHP，前端基于jQuery和BootstrapCo.MZ 企业系统 
 
 轻量级企业网站管理系统 
 运行环境:PHP5.3+, MySQL5.0 
 
系统预览 
 
 系统下载：http://www.tecmz.com  
 预览地址：http://co.tecmz.com  
 
各种设备自适应 
 
 响应式的网站设计能够对用户产生友好度，并且对于
    
                                
    • 
                                
  • Transaction and redelivery in JMS (JMS的事务和失败消息重发机制)
                                    darrenzhu
jms事务承认MQacknowledge
                                    
    JMS Message Delivery Reliability and Acknowledgement Patterns 
 
http://wso2.com/library/articles/2013/01/jms-message-delivery-reliability-acknowledgement-patterns/ 
 
 
Transaction and redelivery in 
    
                                
    • 
                                
  • Centos添加硬盘完全教程
                                    dcj3sjt126com
linuxcentoshardware
                                    
    Linux的硬盘识别: 
 sda        表示第1块SCSI硬盘 
 hda       表示第1块IDE硬盘 
 scd0      表示第1个USB光驱 
 一般使用“fdisk -l”命
    
                                
    • 
                                
  • yii2 restful web服务路由
                                    dcj3sjt126com
PHPyii2
                                    
    路由 
随着资源和控制器类准备，您可以使用URL如 http://localhost/index.php?r=user/create访问资源，类似于你可以用正常的Web应用程序做法。 
在实践中，你通常要用美观的URL并采取有优势的HTTP动词。 例如，请求POST /users意味着访问user/create动作。 这可以很容易地通过配置urlManager应用程序组件来完成 如下所示
    
                                
    • 
                                
  • MongoDB查询(4)——游标和分页[八]
                                    eksliang
mongodbMongoDB游标MongoDB深分页
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2177567 一、游标 
        数据库使用游标返回find的执行结果。客户端对游标的实现通常能够对最终结果进行有效控制，从shell中定义一个游标非常简单，就是将查询结果分配给一个变量（用var声明的变量就是局部变量），便创建了一个游标，如下所示： 
> var 
    
                                
    • 
                                
  • Activity的四种启动模式和onNewIntent()
                                    gundumw100
android
                                    
    Android中Activity启动模式详解 
 
　　在Android中每个界面都是一个Activity，切换界面操作其实是多个不同Activity之间的实例化操作。在Android中Activity的启动模式决定了Activity的启动运行方式。 
 
　　Android总Activity的启动模式分为四种： 
 
 

Activity启动模式设置：

        <acti
    
                                
    • 
                                
  • 攻城狮送女友的CSS3生日蛋糕
                                    ini
htmlWebhtml5csscss3
                                    
    在线预览：http://keleyi.com/keleyi/phtml/html5/29.htm 
  
代码如下： 
  
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>攻城狮送女友的CSS3生日蛋糕-柯乐义<
    
                                
    • 
                                
  • 读源码学Servlet（1）GenericServlet 源码分析
                                    jzinfo
tomcatWebservlet网络应用网络协议
                                    
    Servlet API的核心就是javax.servlet.Servlet接口，所有的Servlet 类（抽象的或者自己写的）都必须实现这个接口。在Servlet接口中定义了5个方法，其中有3个方法是由Servlet 容器在Servlet的生命周期的不同阶段来调用的特定方法。 
  
  
先看javax.servlet.servlet接口源码：  
package 
    
                                
    • 
                                
  • JAVA进阶：VO(DTO)与PO(DAO)之间的转换
                                    snoopy7713
javaVOHibernatepo
                                    
      
PO即 Persistence Object　　VO即 Value Object 
　VO和PO的主要区别在于：　　VO是独立的Java Object。　　PO是由Hibernate纳入其实体容器（Entity Map）的对象，它代表了与数据库中某条记录对应的Hibernate实体，PO的变化在事务提交时将反应到实际数据库中。 
　实际上，这个VO被用作Data Transfer 
    
                                
    • 
                                
  • mongodb group by date 聚合查询日期 统计每天数据（信息量）
                                    qiaolevip
每天进步一点点学习永无止境mongodb纵观千象
                                    
    /* 1 */
{
    "_id" : ObjectId("557ac1e2153c43c320393d9d"),
    "msgType" : "text",
    "sendTime" : ISODate("2015-06-12T11:26:26.000Z")
    
                                
    • 
                                
  • java之18天 常用的类(一)
                                    Luob.
MathDateSystemRuntimeRundom
                                    
    System类 
 

import java.util.Properties;

/**
 * System:
 *  out:标准输出,默认是控制台
 *  in:标准输入,默认是键盘
 * 
 *  描述系统的一些信息
 *  获取系统的属性信息:Properties getProperties();
 *  
 * 
 *
 */
public class Sy
    
                                
    • 
                                
  • maven
                                    wuai
maven
                                    
    1、安装maven：解压缩、添加M2_HOME、添加环境变量path 
2、创建maven_home文件夹，创建项目mvn_ch01,在其下面建立src、pom.xml，在src下面简历main、test、main下面建立java文件夹 
3、编写类，在java文件夹下面依照类的包逐层创建文件夹，将此类放入最后一级文件夹 
4、进入mvn_ch01 
 4.1、mvn compile ,执行后会在
    
                                
    •