『手撕 Mybatis 源码』05 - SqlSession 执行主流程

SqlSession 执行主流程

获取 BoundSql

1. 经过加载完所有配置之后，继续梳理执行 sql 的过程

public class MybatisTest {
  @Test
  public void test1() throws IOException {
	...
	// 4. 委派给 Executor 来执行，Executor 执行时又会调用很多其他组件（参数设置、解析 sql 的获取，sql 的执行、结果集的封装）
	User user = sqlSession.selectOne("user.findUserById", 1);
    ...
  }
}

2. 当调用 selectOne() 时，底层将会调用的是 selectOne(java.lang.String, java.lang.Object)

public class DefaultSqlSession implements SqlSession {
  ...
  @Override
  public <T> T selectOne(String statement, Object parameter) {
    // Popular vote was to return null on 0 results and throw exception on too many.
    List<T> list = this.selectList(statement, parameter);
  	...
  }
}

3. 继续调用时，会先装入默认的分页器 RowBounds，然后继续调用重载的 selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds)

public class DefaultSqlSession implements SqlSession {
  ...
  @Override
  public <E> List<E> selectList(String statement, Object parameter) {
    // 调用重载方法
    return this.selectList(statement, parameter, RowBounds.DEFAULT);
  }
}

4. 继续调用，也会装入空的 ResultHandler，继续调用重载的 selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler)

public class DefaultSqlSession implements SqlSession {
  ...
  @Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    // 参数4：结果集处理器
    return selectList(statement, parameter, rowBounds, Executor.NO_RESULT_HANDLER);
  }
}

5. 通过传入 statementId 即 “user.findUserById”，然后 configuration 对象拿到 MappedStatement 对象，然后利用执行器来执行查询

public class DefaultSqlSession implements SqlSession {
  ...
  private final Configuration configuration;
  private final Executor executor;
  ...
  private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
  	 ...
     // 根据传入的 statementId 即 user.findUserById，获取 MappedStatement 对象
     MappedStatement ms = configuration.getMappedStatement(statement);
     // 调用执行器的查询方法
     // wrapCollection(parameter) 是用来装饰集合或者数组参数
     return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
  }
}

6. 在执行器执行的查询时，是调用经过封装后的 CachingExecutor 的 query() 方法。该方法会从 MappedStatement 对象中拿到对应的 BoundSql 对象

public class CachingExecutor implements Executor {
  ...
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 获取绑定的 SQL 语句，比如 "SELECT * FROM user WHERE id = ? "
    // 其中 parameterObject 是 1
    BoundSql boundSql = ms.getBoundSql(parameterObject);
	...
  }
}

• 其中，MappedStatement 对象会将参数 parameterObject 传入，然后委托 SqlSource 来获取 BoundSql，从上面的流程下来是不涉及动态 sql，所以这个 SqlSource 为 StaticSqlSource

public final class MappedStatement { 
  ...
  private SqlSource sqlSource;
  ...
  public BoundSql getBoundSql(Object parameterObject) {
    // sqlSource 是解析 SELECT id, name FROM  user WHERE id = #{id} 之后得到的源集
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    ...
 }
}

• StaticSqlSource 会把 configuration、sql、parameterMappings、parameterObject 对象封装到 BoundSql 内并且返回

public class StaticSqlSource implements SqlSource {

  private final String sql;
  private final List<ParameterMapping> parameterMappings;
  private final Configuration configuration;
  
  @Override
  public BoundSql getBoundSql(Object parameterObject) {
    /*
    	sql：SELECT id, name FROM  user WHERE id = ?
    	parameterMappings：ParameterMapping{property='id', mode=IN, javaType=class java.lang.Integer, jdbcType=null, numericScale=null, resultMapId='null', jdbcTypeName='null', expression='null'}
    	parameterObject：现在是 1
    */
    return new BoundSql(configuration, sql, parameterMappings, parameterObject);
  }
}

• 拿到 BoundSql 后，先检查参数是不是一个对象映射，需要获取参数对应的映射位，但是现在的映射文件的 sql 输入只是个整形，所以这里执行是空，最后 MappedStatement 对象直接返回 BoundSql 对象，然后 CachingExecutor 就拿到对应的 BoundSql

public final class MappedStatement { 
  ...
  private SqlSource sqlSource;
  ...
  public BoundSql getBoundSql(Object parameterObject) {
  	// 拿到了 boundSql 
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings == null || parameterMappings.isEmpty()) {
      boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }

    // 这次是空，这里检查参数的映射对象，即 ResultMap
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
      String rmId = pm.getResultMapId();
      ...
    }
    // 直接返回
    return boundSql;
  }
}

7. 总结
   

生成 CacheKey

1. 问题

• CacheKey 是由几部分构成的，怎么生成的？
• 怎么完成的 CacheKey 比较，怎么保证 CacheKey 的唯一性？

3. 对于 SqlSession 而言，它会把实际执行交给 Executor，而我们知道在 MyBatis 中会话级别是有缓存的，那么这个缓存 Key 是怎么构造，就是在 CachingExecutor 当中，根据 MappedStatement、parameterObject 实际参数、rowBounds 分页对象以及 BoundSql 来构造的

public class CachingExecutor implements Executor {
  ...
  //第一步
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 获取绑定的 SQL 语句，比如 "SELECT * FROM user WHERE id = ? "
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    // 生成缓存Key
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    ...
  }
}

4. 在 CachingExecutor 中，它会委派 SimpleExecutor 来创建缓存建

public class CachingExecutor implements Executor {

  private final Executor delegate;
  ...
  @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
     // delegate 这个属性就是被包装的 executor，现在是 simpleExecutor
    return delegate.createCacheKey(ms, parameterObject, rowBounds, boundSql); 
  }
}

5. SimpleExecutor 首先会创建一个 CacheKey 对象，这个对象会初始化各种算子参数，用于后面的缓存计算，缓存 Key 的组成部分如下

public class CacheKey implements Cloneable, Serializable {

  private static final int DEFAULT_MULTIPLIER = 37;
  private static final int DEFAULT_HASHCODE = 17;
  ...
  private final int multiplier; // 参与 hash 运算的乘数
  private int hashcode; // cachekey 的 hash 值，在 update 函数中实时算出来
  private long checksum; // 校验和，hash 值的和
  private int count; // updateList 的中的元素个数
  // 根据该集合中的元素判断两个 cacheKey 是否相同
  private List<Object> updateList;

  public CacheKey() {
    this.hashcode = DEFAULT_HASHCODE;
    this.multiplier = DEFAULT_MULTIPLIER;
    this.count = 0;
    this.updateList = new ArrayList<>();
  }
}

6. 回到 SimpleExecutor，它其实调用的是父类 BaseExecutor 的 createCacheKey() 方法，会根据 MappedStatement、parameterObject 实际参数、rowBounds 分页对象以及 BoundSql 来计算 CacheKey 内的哈希值

public abstract class BaseExecutor implements Executor {
  ...
  @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    // 创建cacheKey对象
    CacheKey cacheKey = new CacheKey();
    // id
    cacheKey.update(ms.getId());
    // 分页参数
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    // sql
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    for (ParameterMapping parameterMapping : parameterMappings) {
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          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);
        }
        // 参数的值
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      // 当前环境的值也会设置
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }
}

• 其中 CacheKey 的 update() 方法会把输入的各种参数计算一次哈希，然后把值也存到里面去

public class CacheKey implements Cloneable, Serializable {
  ...
  public void update(Object object) {
    // 获取参数的object的hash值
    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);

    // 更新count 、checksum以及hashcode的值
    count++;
    checksum += baseHashCode;
    baseHashCode *= count;
    hashcode = multiplier * hashcode + baseHashCode;

    // 将对象添加到list集合中
    updateList.add(object);
  }
}

• 生成的哈希值如下
  

7. 总结

• 最后生成的 Key 找缓存值流程如下
  
• 生成 CacheKey 流程
  

缓存优先级

1. 问题

• 如果开启了一二级缓存，究竟是调用一级缓存优先还是二级缓存？

2. 首先配置文件中，开启二级缓存

<mapper namespace="user">

  <cache>cache>
  ...
mapper>

3. 拿到 CacheKey、parameterObject、MappedStatement、BoundSql、RowBounds 时候，开始执行真正的查询

public class CachingExecutor implements Executor {
  ...
  // 第一步
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    ...
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
}

4. query() 方法

• 首先会从 MappedStatement 拿到二级缓存，然后检查对应的 sql 是否配置了 flushCache=true，是的话，先把二级缓存清空了
• 然后判断对应语句是否使用缓存 useCache，默认是开启的
• 然后根据 StatementType 确定是否处理出参参数，这里是 PREPARED 类型，不是存储过程（CALLABLE 类型），所以不处理
• 再从二级缓存中查询数据，没有委托给 SimpleExecutor 查询一级缓存和数据库，最后把查出来的数据放回到二级缓存（暂时是存到 map 集合，实际还没存到二级缓存）

public class CachingExecutor implements Executor {

  private final Executor delegate;
  private final TransactionalCacheManager tcm = new TransactionalCacheManager();
  ...
  @Override
  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) {
      // 刷新（每次查询前清空）二级缓存 （存在缓存且 flushCache 为true时）
      flushCacheIfRequired(ms);
      // 默认就是 true    
      // 
      if (ms.isUseCache() && resultHandler == null) { 
		// 处理输出参数，存储过程才会处理，这里 StatementType 是 PREPARED 类型
        ensureNoOutParams(ms, boundSql);
        // 从二级缓存中查询数据
        List<E> list = (List<E>) tcm.getObject(cache, key);
        // 如果二级缓存中没有查询到数据，则查询一级缓存及数据库
        if (list == null) {
          // 委托给 BaseExecutor 执行
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          // 将查询结果 要存到二级缓存中（注意：此处只是存到map集合中，没有真正存到二级缓存中）
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    // 委托给 BaseExecutor 执行
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
}

5. 委托给 SimpleExecutor 父类的 query() 方法

• 首先判断 sql 是否配置了 flushCacheRequired，是的话会在执行器执行之前，清空本地以及缓存
• 然后从一级缓存中获取数据
• 如果有缓存结果，再判断是否是存储过程类型（CALLABLE 类型），是的话处理输出参数，否则的话直接从数据库里面查询结果

public abstract class BaseExecutor implements Executor {
  protected PerpetualCache localCache;
  ...
  @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());
    // 如果该执行器已经关闭，则抛出异常
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    // 1. 如果配置了 flushCacheRequired 为 true，则会在执行器执行之前就清空本地一级缓存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      // 1.1. 清空缓存
      clearLocalCache();
    }
    List<E> list;
    try {
      // 2. 查询堆栈 + 1
      queryStack++;
      // 从一级缓存中获取数据
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        // 3.1. 已有缓存结果，则处理本地缓存结果输出参数（只有存储过程会走）
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        // 3.2. 没有缓存结果，则从数据库查询结果
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      // 查询堆栈数 -1
      queryStack--;
    }
    ...
  }
}

6. 总结
   

StatementHandler 预处理得到 Statement 对象

1. SimpleExecutor 从缓存中拿不到到数据，就需要从 db 中获取

public abstract class BaseExecutor implements Executor {
  ...
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ...
    try {
      ...
      } else {
        // 3.2. 没有缓存结果，则从数据库查询结果
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
  }
}

2. 然后执行 SimpleExecutor 的 doQuery()，这是由 SimpleExecutor 实现的。其中查询前会在本地缓存中，添加占位符，拿到数据后再移除

public abstract class BaseExecutor implements Executor {
  ...
  private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    // 1. 首先向本地缓存中存入一个 ExecutionPlaceholder 的枚举类占位 value
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      // 2. 执行 doQuery 方法
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      // 3. 执行完成移除这个 key
      localCache.removeObject(key);
    }
    // 4. 查询结果存入缓存中
    localCache.putObject(key, list);
    // 5. 如果 MappedStatement 的类型为 CALLABLE，则向 localOutputParameterCache 缓存中存入 value 为 parameter 的缓存
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }
}

3. SimpleExecutor 先从 MappedStatement 拿到 Configuration 对象，然后通过 Configuration 对象创建 StatementHandler 语句处理器

public class SimpleExecutor extends BaseExecutor {
  
  protected Executor wrapper;
  ...
  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      // 1. 获取配置实例
      Configuration configuration = ms.getConfiguration();
      // 2. new 一个 StatementHandler 实例
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      ...
    } finally {
      // 5. 关闭statement
      closeStatement(stmt);
    }
  }
}

4. StatementHandler 创建很关键，它会先通过 RoutingStatementHandler 以及插件拦截装饰后返回 StatementHandler 对象

• 【重点】： 这里的插件机制是 MyBatis 扩展的关键地方之一

public class Configuration {
  ...
  protected final InterceptorChain interceptorChain = new InterceptorChain();
  ...
  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    // 创建路由功能的 StatementHandler，根据 MappedStatement 中的 StatementType，可以在 sql 中配置
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    // 插件机制：对核心对象进行拦截
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }
}

• 其中 StatementHandler 组织如下
  
  • BaseStatementHandler： 基础语句处理器（抽象类），它基本把语句处理器接口的核心部分都实现了，包括配置绑定、执行器绑定、映射器绑定、参数处理器构建、结果集处理器构建、语句超时设置、语句关闭等，并另外定义了新的方法 instantiateStatement() 供不同子类实现以便获取不同类型的语句连接，子类可以普通执行 SQL 语句，也可以做预编译执行，还可以执行存储过程等
  • SimpleStatementHandler：普通语句处理器，继承 BaseStatementHandler 抽象类，对应 java.sql.Statement 对象的处理，处理普通的不带动态参数运行的 SQL，即执行简单拼接的字符串语句，同时由于 Statement 的特性，SimpleStatementHandler 每次执行都需要编译 SQL （注意：我们知道 SQL 的执行是需要编译和解析的）
  • PreparedStatementHandler：预编译语句处理器，继承 BaseStatementHandler 抽象类，对应 java.sql.PrepareStatement 对象的处理，相比上面的普通语句处理器，它支持可变参数 SQL 执行，由于 PrepareStatement 的特性，它会进行预编译，在缓存中一旦发现有预编译的命令，会直接解析执行，所以减少了再次编译环节，能够有效提高系统性能，并预防 SQL 注入攻击（所以是系统默认也是我们推荐的语句处理器）
  • CallableStatementHandler：存储过程处理器，继承 BaseStatementHandler 抽象类，对应 java.sql.CallableStatement 对象的处理，很明了，它是用来调用存储过程的，增加了存储过程的函数调用以及输出/输入参数的处理支持
  • RoutingStatementHandler：路由语句处理器，直接实现了 StatementHandler 接口，作用如其名称，确确实实只是起到了路由功能，并把上面介绍到的三个语句处理器实例作为自身的委托对象而已，所以执行器在构建语句处理器时，都是直接 new 了 RoutingStatementHandler 实例

5. RoutingStatementHandler 会根据 sql 的 statementType 选择对应处理的 handler

public class RoutingStatementHandler implements StatementHandler {

  private final StatementHandler delegate;

  public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    // 可以在 Mapper.xml 对 sql 指定 statementType
    switch (ms.getStatementType()) {
      case STATEMENT:
        delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case PREPARED:
        delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case CALLABLE:
        delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      default:
        throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
    }
  }
}

6. 获取到 StatementHandler 之后，就需要执行第 3 步创建 Statement 对象

public class SimpleExecutor extends BaseExecutor {
  ...
  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      // 1. 获取配置实例
      Configuration configuration = ms.getConfiguration();
      // 2. new 一个 StatementHandler 实例
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 3. 准备处理器，主要包括创建 statement 以及动态参数的设置
      stmt = prepareStatement(handler, ms.getStatementLog());
      ...
    } finally {
      // 5. 关闭statement
      closeStatement(stmt);
    }
  }
}

7. SimpleExecutor 获取 Statement 对象前，会通过 JDBCTransaction 先获取 Connection 对象，即通过 DataSource 返回 Connection 对象。如果开启了日志调试模式，返回的 Connection 对象是经过代理的。然后 RoutingStatementHandler 做预处理得到预编译的 Statement 对象，并参数化后返回 Statement 对象

public class SimpleExecutor extends BaseExecutor {
  
  protected Transaction transaction;
  ...
  // 这个是父类的方法
  protected Connection getConnection(Log statementLog) throws SQLException {
    Connection connection = transaction.getConnection();
    if (statementLog.isDebugEnabled()) { // 是否进行日志调试
      return ConnectionLogger.newInstance(connection, statementLog, queryStack);
    } else {
      return connection;
    }
  }
  ...
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    // 1. 获取代理后（增加日志功能）的Connection对象
    Connection connection = getConnection(statementLog);
    // 2. 创建 Statement 对象（可能是一个 SimpleStatement，一个 PreparedStatement 或 CallableStatement）
    stmt = handler.prepare(connection, transaction.getTimeout());
    // 3. 参数化处理
    handler.parameterize(stmt);
    // 4. 返回执行前最后准备好的Statement对象
    return stmt;
  }
}

8. RoutingStatementHandler 再次委派 PreparedStatmentHandler 来处理

public class RoutingStatementHandler implements StatementHandler {

  private final StatementHandler delegate;
  ...
  @Override
  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    return delegate.prepare(connection, transactionTimeout);
  }
}

9. PreparedStatmentHandler 会通过拿到 BoundSql 中的 sql 之后，通过 Connection 对 sql 进行预编译，得到 PrepareStatement 并返回

public class PreparedStatementHandler extends BaseStatementHandler {
  ...
  protected BoundSql boundSql;
  // 这个是父类 BaseStatementHandler 的方法
  @Override
  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      statement = instantiateStatement(connection);
      ...
      return statement; // 获取预编译对象
    } catch (SQLException e) {
      ...
    }
  }
  ...
  @Override
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    String sql = boundSql.getSql();
    if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
       ...
    } else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
      return connection.prepareStatement(sql); //# 获取预编译对象
    } else {
      ...
    }
  }
}

10. 总结
    

Statement 参数化设置

1. 上面已经阐述到 SimpleExecutor 获取预编译 Statement 对象，下面继续看看参数化的过程，下面会继续交由 RoutingStatementHandler 来 Statement 对象参数化处理

public class SimpleExecutor extends BaseExecutor {
  ...
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    ...
    // 3. 参数化处理
    handler.parameterize(stmt);
    // 4. 返回执行前最后准备好的Statement对象
    return stmt;
  }
}

2. RoutingStatementHandler 委派 PreparedStatementHandler 来执行参数设置，内部调用的是 ParameterHandler 来处理参数化

public class PreparedStatementHandler extends BaseStatementHandler {
  
  protected final ParameterHandler parameterHandler;
  ...
  @Override
  public void parameterize(Statement statement) throws SQLException {
    parameterHandler.setParameters((PreparedStatement) statement);
  }
}

3. ParameterHandler 参数化处理流程

• 首先从 BoundSql 中，拿到参数化映射列表 ParameterMappings，这个列表是有序的，因为都是从原来的 sql 中按序提取的，然后遍历这个表
• 拿到这个表之后，取到属性名后，进行一系列校验，包括查看 parameterObject 是不是为空，TypeHandlerRegistry 有没有对应参数的处理方法
• 从 ParameterMapping 拿到对应 TypeHandler、JdbcType，然后通过 TypeHandler 来参数化
• 最后把参数化后的 Statement 对象返回到 SimpleExecutor

public class DefaultParameterHandler implements ParameterHandler {
  // 持有 typeHandler 注册器
  private final TypeHandlerRegistry typeHandlerRegistry;
  // 持有MappedStatement实例，这是一个静态的xml的一个数据库操作节点的静态信息而已
  private final MappedStatement mappedStatement;
  // 当前实际执行前的参数对象
  private final Object parameterObject;
  // 动态语言被执行后的结果 sql
  private final BoundSql boundSql;
  private final Configuration configuration;
  ...
  
  @Override
  public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    // 1. 获取boundSql中的参数映射信息列表
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
      // 1.1. 遍历参数映射列表，这个列表信息就是我们xml文件中定义的某个查询语句的所有参数映射信息，注意这个List中的参数映射元素的顺序是和真实xml中sql的参数顺序对应的
      for (int i = 0; i < parameterMappings.size(); i++) {
        ParameterMapping parameterMapping = parameterMappings.get(i);
        // 1.2. 只有入参类型才会设置 PreparedStatement
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          // 取出参数名，这里比如说是'id'
          String propertyName = parameterMapping.getProperty();
          if (boundSql.hasAdditionalParameter(propertyName)) {
          	...
           // 有没有对应的这个类型转换处理器
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          } else {
            // 1.3. 这一步的工作就是从当前实际传入的参数中获取到指定key（'id'）的value值，比如是'15800000000'
            // 经过测试，其实就是从 map 或者 对象，拿到这个对应的值
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }

          // 2. 获取该参数对应的typeHandler
          TypeHandler typeHandler = parameterMapping.getTypeHandler();

          // 2.1. 获取该参数对应的jdbcType
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) {
            jdbcType = configuration.getJdbcTypeForNull();
          }
          try {
            // 3. 重点是调用每个参数对应的 typeHandler 的 setParameter 方法为该ps设置正确的参数值
            typeHandler.setParameter(ps, i + 1, value, jdbcType);
          } catch (TypeException | SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          }
        }
      }
    }
  }
}

4. 拿到参数化的 Statement 对象后，通过 RoutingStatementHandler 真正执行查询

public class SimpleExecutor extends BaseExecutor {
  ...
  @Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      ...
      // 2
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      ...
      // 4. 执行真正的数据库操作调用
      return handler.query(stmt, resultHandler);
    } finally {
      // 5. 关闭statement
      closeStatement(stmt);
    }
  }
}

5. RoutingStatementHandler 再次委派 PreparedStatementHandler 执行查询。PreparedStatementHandler 拿到 PreparedStatement 后，直接执行查询。然后通过 ResultSetHandler 处理结果集，最后返回查询结果

public class PreparedStatementHandler extends BaseStatementHandler {

  protected final ResultSetHandler resultSetHandler;
  ...
  @Override
  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    // 结果集处理
    return resultSetHandler.handleResultSets(ps);
  }
}

6. 总结
   

解析结果集

1. 问题

• 什么逻辑来完成的查询结果处理

2. 继续回到 PreparedStatementHandler 查询执行，经过执行查询获得结果集之后，需要 ResultSetHandler 对查询结果进行处理

public abstract class BaseStatementHandler implements StatementHandler {
  
  protected final ResultSetHandler resultSetHandler;
  ...
  @Override
  public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    // 1. 结果集处理
    return resultSetHandler.handleResultSets(ps);
  }
}

3. ResultSetHandler 实际的实现是 DefaultResultSetHandler，处理的流程如下

• 首先对 Statement 获取第一个结果集，并且把结果集包装成 ResultSetWrapper，它会把结果集的 columnNames、classNames、jdbcTypes 属性包装到里面
• 通过 MappedStatement 拿到 Mapper.xml 在 sql 语句中配置的、所有要映射的 ResultMap
• 然后遍历所有的 ResultMap，根据 ResultSetWrapper 映射的所有结果集存放到 multipleResults 局部变量集合中
• 最后返回 multipleResults，如果只有一个结果集，就从 multipleResults 取出第一个

public class DefaultResultSetHandler implements ResultSetHandler {

  private final MappedStatement mappedStatement;
  private final Configuration configuration;
  ...
  private ResultSetWrapper getFirstResultSet(Statement stmt) throws SQLException {

    ResultSet rs = stmt.getResultSet();
    while (rs == null) {
    
      if (stmt.getMoreResults()) {
        rs = stmt.getResultSet();
      } else {
        if (stmt.getUpdateCount() == -1) {
          break;
        }
      }
    }
    // 包装结果集
    return rs != null ? new ResultSetWrapper(rs, configuration) : null;
  }
  
  // HANDLE RESULT SETS
  // 将 Statement 执行后产生的结果集（可能有多个结果集）映射为结果列表
  // （1）获取到 ResultSet 结果集对象  （2）获取映射关系  （3）根据映射关系封装实体

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

    // 创建结果容器
    final List<Object> multipleResults = new ArrayList<>();

    int resultSetCount = 0;
    // 1. 这里是获取第一个结果集，将传统 JDBC 的 ResultSet 包装成一个包含结果列元信息的 ResultSetWrapper 对象
    ResultSetWrapper rsw = getFirstResultSet(stmt);

    // 2. 这里是获取所有要映射的 ResultMap（按照逗号分割出来的），例如在 Mapper.xml 配置的 
    List<ResultMap> resultMaps = mappedStatement.getResultMaps();
    // 要映射的 ResultMap 的数量
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    // 3. 循环处理每个 ResultMap，从第一个开始处理
    while (rsw != null && resultMapCount > resultSetCount) {
      // 得到结果映射信息（取出第一个结果集）
      ResultMap resultMap = resultMaps.get(resultSetCount);
      // 4. 根据映射规则对结果集进行 pojo 转化（最后放入 multipleResults 结果集中）
      handleResultSet(rsw, resultMap, multipleResults, null);
      // 处理下个结果集
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

    // 对应  标签的 resultSets 属性，一般不使用该属性，忽略
    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
       ...
    }

    // 5. 如果只有一个结果集合，则直接从多结果集中取出第一个
    return collapseSingleResultList(multipleResults);
  }

  @SuppressWarnings("unchecked")
  private List<Object> collapseSingleResultList(List<Object> multipleResults) {
    return multipleResults.size() == 1 ? (List<Object>) multipleResults.get(0) : multipleResults;
  }
}
 
  
 
   
继续深挖根据映射规则进行结果集，首先通过 ObjectFactory 初始化 DefaultResultHandler，然后对结果集进行映射，转换的结果存入 DefaultResultHandler 中，最后把结果放入 multipleResults
 
  
 
  
public class DefaultResultSetHandler implements ResultSetHandler {
  private final ResultHandler<?> resultHandler;
  private final ObjectFactory objectFactory;
  private final RowBounds rowBounds;
  ...
  private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    try {
      if (parentMapping != null) {
        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
      } else {
        if (resultHandler == null) {
          // 1. 实例化 DefaultResultHandler
          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
          // 2. 对结果集进行映射，转换的结果存入 defaultResultHandler
          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
          // 3. multipleResults 最终的结构 List>
          multipleResults.add(defaultResultHandler.getResultList());
        } else {
          // 存储过程相关，不太需要关注
          handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
        }
      }
    } finally {
      // issue #228 (close resultsets)
      closeResultSet(rsw.getResultSet());
    }
  }
}
 
  
 
   
接下来开始对结果集进行映射，首先判断是否有内置嵌套的结果映射，如果不是，则执行简单结果映射
 
  
 
  
public class DefaultResultSetHandler implements ResultSetHandler {
  ...
  public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    // 是否有内置嵌套的结果映射
    if (resultMap.hasNestedResultMaps()) {
      ensureNoRowBounds();
      checkResultHandler();
      // 嵌套结果映射
      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
      // 1. 简单结果映射，这次只看这个处理
      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
  }
}
 
  
 
   
执行简单结果映射，先获取结果集信息，然后根据分页信息只提取部分数据，然后遍历 resultSet 的每一行数据转化成 POJO，再保存映射结果
 
  
 
  
public class DefaultResultSetHandler implements ResultSetHandler {
  ...
  private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
      throws SQLException {
    DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
    // 1. 获取结果集信息
    ResultSet resultSet = rsw.getResultSet();
    // 2. 根据分页信息，提取相应数据
    skipRows(resultSet, rowBounds);
    /*
       3. 处理和赋值多条记录
     */
    while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
      // 通过标签的子标签对结果映射进行鉴别
      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
      // 4. 将查询结果封装到 POJO 中，关键位置
      Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
      // 5. 保存映射结果
      storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
    }
  }
}
 
  
 
   
执行查询结果封装到 POJO。首先通过 ObjectFactory 创建结果映射的 PO 类对象，然后通过 Configuration 创建 MetaObject 对象，并把 PO 类（即代码里的 rowValue，其实相当于给 PO 多加了点元信息）存到里面去，然后根据 resultMap 结果映射、ResultSetWrapper 封装好的结果集，把值映射到创建到的 PO 类里面去。这三者的关系可以看作 ResultSetWrapper 是 JDBC 对象值，resultMap 是 JDBC 与 Java PO 属性关系映射表，MetaObject 包含元信息的 PO 类对象
 
  
 
  
public class DefaultResultSetHandler implements ResultSetHandler {
  ...
  private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
    // 延迟加载的映射信息
    final ResultLoaderMap lazyLoader = new ResultLoaderMap();
    // 1. 根据 resultType 的值创建要映射的 PO 类对象
    Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      // 2. 获取 MetaObject 对象，为后面赋值做准备，也把 rowValue 封进去了
      final MetaObject metaObject = configuration.newMetaObject(rowValue);
      boolean foundValues = this.useConstructorMappings;
      // 3. 是否应用自动映射，也就是通过 resultType 进行映射
      if (shouldApplyAutomaticMappings(resultMap, false)) {
        // 4. 根据 columnName 和 type 属性名映射赋值，存到 rowValue 中
        foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
      }
      // 根据我们配置 ResultMap 的 column 和 property 映射赋值
      // 如果映射存在 nestedQueryId，会调用 getNestedQueryMappingValue 方法获取返回值
      foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
      foundValues = lazyLoader.size() > 0 || foundValues;
      rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    // 5. 返回结果
    return rowValue;
  }
}
 
  
 
   
创建对象过程其实就是委派给 ObjectFactory 来创建的，也就是上面第 1 步
 
  
 
  
public class DefaultResultSetHandler implements ResultSetHandler {
  ...
  private final ObjectFactory objectFactory;
  ...
  private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, ResultLoaderMap lazyLoader, String columnPrefix) throws SQLException {
    this.useConstructorMappings = false; // reset previous mapping result
    final List<Class<?>> constructorArgTypes = new ArrayList<>();
    final List<Object> constructorArgs = new ArrayList<>();
    // 1. 创建结果映射的PO类对象
    Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix);
    if (resultObject != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      // 获取要映射的 PO 类的属性信息
      final List<ResultMapping> propertyMappings = resultMap.getPropertyResultMappings();
      for (ResultMapping propertyMapping : propertyMappings) {
        // issue gcode #109 && issue #149
        // 延迟加载处理
        if (propertyMapping.getNestedQueryId() != null && propertyMapping.isLazy()) {
          // 通过动态代理工厂，创建延迟加载的代理对象
          resultObject = configuration.getProxyFactory().createProxy(resultObject, lazyLoader, configuration, objectFactory, constructorArgTypes, constructorArgs);
          break;
        }
      }
    }
    this.useConstructorMappings = resultObject != null && !constructorArgTypes.isEmpty();
    // 2. 返回结果
    return resultObject;
  }
  
  private Object createResultObject(ResultSetWrapper rsw, ResultMap resultMap, List<Class<?>> constructorArgTypes, List<Object> constructorArgs, String columnPrefix)
      throws SQLException {
    final Class<?> resultType = resultMap.getType();
    final MetaClass metaType = MetaClass.forClass(resultType, reflectorFactory);
    final List<ResultMapping> constructorMappings = resultMap.getConstructorResultMappings();
    if (hasTypeHandlerForResultObject(rsw, resultType)) {
		...
    } else if (resultType.isInterface() || metaType.hasDefaultConstructor()) {
      // 1. 对象工厂创建对象
      return objectFactory.create(resultType);
    } else if (shouldApplyAutomaticMappings(resultMap, false)) {
      return createByConstructorSignature(rsw, resultType, constructorArgTypes, constructorArgs);
    }
    ...
  }
}
 
  
 
   
由于因为这次测试源码的 case 在 Mapper.xml 中定义的 sql 的返回映射属性是 resultType 所以 shouldApplyAutomaticMappings() 返回 true，所以会通过 applyAutomaticMappings 执行 columnName 和 type 属性名映射赋值，存到 rowValue 中 
    
 
     
首先会通过 createAutomaticMappings() 得到属性映射列表 
 
     
然后遍历这个属性映射列表，通过 TypeHandler 从 ResultSet 拿出属性值
 
     
最后通过 MetaObject 将属性值设置到 rowValue
 
    
 
 
  
 
  
public class DefaultResultSetHandler implements ResultSetHandler {
  ...
  private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
    // 1. 创建属性映射表
    List<UnMappedColumnAutoMapping> autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
    boolean foundValues = false;
    if (!autoMapping.isEmpty()) {
      // 2. 遍历属性映射表
      for (UnMappedColumnAutoMapping mapping : autoMapping) {
        // 3. 从 ResultSet 拿到值
        final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
        if (value != null) {
          foundValues = true;
        }
        if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
          // 4. 设置到 rowValue 中
          metaObject.setValue(mapping.property, value);
        }
      }
    }
    return foundValues;
  }
}
 
  
 
   
得到解析后的结果，返回给 DefaultResultSetHandler 之后，就可以把值映射值拿到，得到最终结果
 
   
总结
 
 
  
 
  
SqlSession 关闭
 
  
 
   
通过 Sqlsession 拿到结果之后，执行完业务流程，就会将 Sqlsession 进行 close()
 
  
 
  
public class MybatisTest {

  @Test
  public void test1() throws IOException {
    ...
    // 4. 关闭 会话
    sqlSession.close();
  }

}
 
  
 
   
Sqlsession 关闭，其实就是对 Executor 进行一个关闭清理处理
 
  
 
  
public class DefaultSqlSession implements SqlSession {

  private final Executor executor;
  ...
  @Override
  public void close() {
    try {
      // 1. 执行关闭
      executor.close(isCommitOrRollbackRequired(false));
      closeCursors();
      dirty = false;
    } finally {
      ErrorContext.instance().reset();
    }
  }
}
 
  
 
   
然后 CachingExecutor 会对事务管理器进行最后的数据 commit 或者 rollback，然后关闭会话
 
  
 
  
public class CachingExecutor implements Executor {
  // 1. 这里还是 SimpleExecutor
  private final Executor delegate;
  private final TransactionalCacheManager tcm = new TransactionalCacheManager();
  ...
  @Override
  public void close(boolean forceRollback) {
    try {
      // issues #499, #524 and #573
      if (forceRollback) {
        tcm.rollback();
      } else {
        tcm.commit();
      }
    } finally {
      delegate.close(forceRollback);
    }
  }
}
 
  
完整流程总结
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(『数据库』,mybatis,java,spring)
        

            

                

                    
Long类型前后端数据不一致
                        igotyback
前端
                        
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
                    
                    
LocalDateTime 转 String
                        igotyback
java开发语言
                        
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
                    
                    
Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
                    
                    
Google earth studio 简介
                        陟彼高冈yu
旅游
                        
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
                    
                    
关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
                    
                    
SQL Server_查询某一数据库中的所有表的内容
                        qq_42772833
SQLServer数据库sqlserver
                        
1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
                    
                    
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
                    
                    
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
                    
                    
深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
                    
                    
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
                    
                    
HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
                    
                    
MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
                    
                    
node.js学习
                        小猿L
node.jsnode.js学习vim
                        
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
                    
                    
python os 环境变量
                        CV矿工
python开发语言numpy
                        
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
                    
                    
【PG】常见数据库、表属性设置
                        江无羡
数据库
                        
PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
                    
                    
nosql数据库技术与应用知识点
                        皆过客，揽星河
NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
                        
Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
                    
                    
SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
                    
                    
insert into select 主键自增_mybatis拦截器实现主键自动生成
                        weixin_39521651
insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
                        
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
                    
                    
Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
                    
                    
简单了解 JVM
                        记得开心一点啊
jvm
                        
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
                    
                    
关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解
                        秋刀prince
mysqlmysql数据库
                        
提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
                    
                    
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
                    
                    
Java企业面试题3
                        马龙强_
java
                        
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
                    
                    
JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
                    
                    
Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
                    
                    
白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
                    
                    
python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
                    
                    
spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
                    
                    
ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
                    
                    
Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
                    
                                
jdk tomcat 环境变量配置
                                    Array_06
javajdktomcat
                                    
Win7 下如何配置java环境变量 
 
1。准备jdk包，win7系统，tomcat安装包（均上网下载即可） 
2。进行对jdk的安装，尽量为默认路径（但要记住啊！！以防以后配置用。。。） 
3。分别配置高级环境变量。 
   电脑-->右击属性-->高级环境变量-->环境变量。 
 
 
分别配置 : 
 
path   
 &nbs
                                
                                
Spring调SDK包报java.lang.NoSuchFieldError错误
                                    bijian1013
javaspring
                                    
        在工作中调另一个系统的SDK包，出现如下java.lang.NoSuchFieldError错误。 
org.springframework.web.util.NestedServletException: Handler processing failed; nested exception is java.l
                                
                                
LeetCode[位运算] - #136 数组中的单一数
                                    Cwind
java题解位运算LeetCodeAlgorithm
                                    
原题链接：#136 Single Number 
要求： 
给定一个整型数组，其中除了一个元素之外，每个元素都出现两次。找出这个元素 
注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间 
难度：中等 
分析： 
题目限定了线性的时间复杂度，同时不使用额外的空间，即要求只遍历数组一遍得出结果。由于异或运算 n XOR n = 0, n XOR 0 = n，故将数组中的每个元素进
                                
                                
qq登陆界面开发
                                    15700786134
qq
                                    
今天我们来开发一个qq登陆界面，首先写一个界面程序，一个界面首先是一个Frame对象，即是一个窗体。然后在这个窗体上放置其他组件。代码如下： 
public class First {         public void initul(){        jf=ne
                                
                                
Linux的程序包管理器RPM
                                    被触发
linux
                                    
在早期我们使用源代码的方式来安装软件时，都需要先把源程序代码编译成可执行的二进制安装程序，然后进行安装。这就意味着每次安装软件都需要经过预处理-->编译-->汇编-->链接-->生成安装文件--> 安装，这个复杂而艰辛的过程。为简化安装步骤，便于广大用户的安装部署程序，程序提供商就在特定的系统上面编译好相关程序的安装文件并进行打包，提供给大家下载，我们只需要根据自己的
                                
                                
socket通信遇到EOFException
                                    肆无忌惮_
EOFException
                                    
java.io.EOFException 
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2281) 
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:
                                
                                
基于spring的web项目定时操作
                                    知了ing
javaWeb
                                    
废话不多说，直接上代码，很简单 配置一下项目启动就行 
1，web.xml 
 

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="h
                                
                                
树形结构的数据库表Schema设计
                                    矮蛋蛋
schema
                                    
原文地址： 
http://blog.csdn.net/MONKEY_D_MENG/article/details/6647488 
 
 
    程序设计过程中，我们常常用树形结构来表征某些数据的关联关系，如企业上下级部门、栏目结构、商品分类等等，通常而言，这些树状结构需要借助于数据库完成持久化。然而目前的各种基于关系的数据库，都是以二维表的形式记录存储数据信息，
                                
                                
maven将jar包和源码一起打包到本地仓库
                                    alleni123
maven
                                    
http://stackoverflow.com/questions/4031987/how-to-upload-sources-to-local-maven-repository 
 
 
 
<project>
  ...
  <build>
    <plugins>
      <plugin>
        <groupI
                                
                                
java IO操作 与 File 获取文件或文件夹的大小，可读，等属性！！！
                                    百合不是茶

                                    
类 File 
File是指文件和目录路径名的抽象表示形式。 
1，何为文件： 
标准文件（txt doc mp3...） 
目录文件（文件夹） 
虚拟内存文件 
  
2，File类中有可以创建文件的 createNewFile（）方法,在创建新文件的时候需要try{} catch(）{}因为可能会抛出异常；也有可以判断文件是否是一个标准文件的方法isFile();这些防抖都
                                
                                
Spring注入有继承关系的类（2）
                                    bijian1013
javaspring
                                    
被注入类的父类有相应的属性，Spring可以直接注入相应的属性，如下所例：1.AClass类 
package com.bijian.spring.test4;

public class AClass {

    private String a;
    private String b;
   
    public String getA() {
        retu
                                
                                
30岁转型期你能否成为成功人士
                                    bijian1013
成长励志
                                    
        很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
                                
                                
【Velocity四】Velocity与Java互操作
                                    bit1129
velocity
                                    
Velocity出现的目的用于简化基于MVC的web应用开发，用于替代JSP标签技术，那么Velocity如何访问Java代码.本篇继续以Velocity三http://bit1129.iteye.com/blog/2106142中的例子为基础， 
     POJO 
   
package com.tom.servlets;

public
                                
                                
【Hive十一】Hive数据倾斜优化
                                    bit1129
hive
                                    
什么是Hive数据倾斜问题 
  
 
 操作：join,group by,count distinct 
 现象：任务进度长时间维持在99%（或100%），查看任务监控页面，发现只有少量（1个或几个）reduce子任务未完成；查看未完成的子任务，可以看到本地读写数据量积累非常大，通常超过10GB可以认定为发生数据倾斜。 
 原因：key分布不均匀 
 倾斜度衡量：平均记录数超过50w且
                                
                                
在nginx中集成lua脚本：添加自定义Http头，封IP等
                                    ronin47
nginx lua csrf
                                    
Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com 
Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 
location /{
                                
                                
java-3.求子数组的最大和
                                    bylijinnan
java
                                    
package beautyOfCoding;


public class MaxSubArraySum {

	/**
	 * 3.求子数组的最大和
题目描述：
输入一个整形数组，数组里有正数也有负数。
数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。
求所有子数组的和的最大值。要求时间复杂度为O(n)。
例如输入的数组为1, -2, 3, 10, -4,
                                
                                
Netty源码学习-FileRegion
                                    bylijinnan
javanetty
                                    
今天看org.jboss.netty.example.http.file.HttpStaticFileServerHandler.java 
可以直接往channel里面写入一个FileRegion对象，而不需要相应的encoder： 
 


		//pipeline（没有诸如“FileRegionEncoder”的handler）：
		public ChannelPipeline ge
                                
                                
使用ZeroClipboard解决跨浏览器复制到剪贴板的问题
                                    cngolon
跨浏览器复制到粘贴板Zero Clipboard
                                    
Zero Clipboard的实现原理 
Zero Clipboard 利用透明的Flash让其漂浮在复制按钮之上，这样其实点击的不是按钮而是 Flash ，这样将需要的内容传入Flash，再通过Flash的复制功能把传入的内容复制到剪贴板。 
Zero Clipboard的安装方法 
首先需要下载 Zero Clipboard的压缩包，解压后把文件夹中两个文件：ZeroClipboard.js 
                                
                                
单例模式
                                    cuishikuan
单例模式
                                    
第一种（懒汉，线程不安全）： 
public class Singleton {   2     private static Singleton instance;   3     pri
                                
                                
spring+websocket的使用
                                    dalan_123

                                    
一、spring配置文件 
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.or
                                
                                
细节问题：ZEROFILL的用法范围。
                                    dcj3sjt126com
mysql
                                    
   1、zerofill把月份中的一位数字比如1，2，3等加前导0 
 
      
mysql> CREATE TABLE t1 (year YEAR(4), month INT(2) UNSIGNED ZEROFILL,    -> day
                                
                                
Android开发10——Activity的跳转与传值
                                    dcj3sjt126com
Android开发
                                    
Activity跳转与传值，主要是通过Intent类，Intent的作用是激活组件和附带数据。 
  
一、Activity跳转 
方法一Intent intent = new Intent(A.this, B.class); startActivity(intent) 
  
方法二Intent intent = new Intent();intent.setCla
                                
                                
jdbc 得到表结构、主键
                                    eksliang
jdbc 得到表结构、主键
                                    
转自博客：http://blog.csdn.net/ocean1010/article/details/7266042 
假设有个con DatabaseMetaData dbmd = con.getMetaData(); rs = dbmd.getColumns(con.getCatalog(), schema, tableName, null); rs.getSt
                                
                                
Android 应用程序开关GPS
                                    gqdy365
android
                                    
要在应用程序中操作GPS开关需要权限： 
 

<uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS" />
 
但在配置文件中添加此权限之后会报错，无法再eclipse里面正常编译，怎么办？ 
1、方法一：将项目放到Android源码中编译； 
2、方法二：网上有人说cl
                                
                                
Windows上调试MapReduce
                                    zhiquanliu
mapreduce
                                    
1.下载hadoop2x-eclipse-plugin https://github.com/winghc/hadoop2x-eclipse-plugin.git 把 hadoop2.6.0-eclipse-plugin.jar 放到eclipse plugin 目录中。 2.下载 hadoop2.6_x64_.zip http://dl.iteye.com/topics/download/d2b
                                
                                
如何看待一些知名博客推广软文的行为？
                                    justjavac
博客
                                    
本文来自我在知乎上的一个回答：http://www.zhihu.com/question/23431810/answer/24588621 
互联网上的两种典型心态： 
 
  当初求种像条狗，如今撸完嫌人丑  
  当初搜贴像条犬，如今读完嫌人软  
 
你为啥感觉不舒服呢？ 
难道非得要作者把自己的劳动成果免费给你用，你才舒服？ 
就如同 Google 关闭了 Gooled Reader，那是
                                
                                
sql优化总结
                                    macroli
sql
                                    
为了是自己对sql优化有更好的原则性，在这里做一下总结，个人原则如有不对请多多指教。谢谢！ 
  
要知道一个简单的sql语句执行效率，就要有查看方式，一遍更好的进行优化。 
  
一、简单的统计语句执行时间 
declare @d datetime ---定义一个datetime的变量set @d=getdate() ---获取查询语句开始前的时间select user_id
                                
                                
Linux Oracle中常遇到的一些问题及命令总结
                                    超声波
oraclelinux
                                    
1.linux更改主机名 
  
(1)#hostname oracledb　　　　临时修改主机名 
(2) vi /etc/sysconfig/network 　　修改hostname 
(3) vi /etc/hosts　　　　　　　　修改IP对应的主机名 
  
2.linux重启oracle实例及监听的各种方法 
（注意操作的顺序应该是先监听，后数据库实例） 
&nbs
                                
                                
hive函数大全及使用示例
                                    superlxw1234
hadoophive函数
                                    
  
具体说明及示例参 见附件文档。  
  
  
文档目录： 
  
目录 
一、关系运算： 4 
1. 等值比较: = 4 
2. 不等值比较: <> 4 
3. 小于比较: < 4 
4. 小于等于比较: <= 4 
5. 大于比较: > 5 
6. 大于等于比较: >= 5 
7. 空值判断: IS NULL 5
                                
                                
Spring 4.2新特性-使用@Order调整配置类加载顺序
                                    wiselyman
spring 4
                                    
4.1 @Order 
 
 Spring 4.2 利用@Order控制配置类的加载顺序 
  
4.2 演示 
 
 两个演示bean 
 
package com.wisely.spring4_2.order;

public class Demo1Service {

}

 
package com.wisely.spring4_2.order;

public class
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.