晴天哥_王志
晴天哥_王志

mybatis-3.4.6 SqlSession执行过程

系列

  • mybatis-3.4.6 配置介绍
  • mybatis-3.4.6 顶层配置解析
  • mybatis-3.4.6 子配置解析
  • mybatis-3.4.6 mapper解析
  • mybatis-3.4.6 SQL执行流程
  • mybatis-3.4.6 SqlSession执行过程
  • mybatis-3.4.6 缓存介绍
  • mybatis-3.4.6 自增主键
  • mybatis-3.4.6 foreach 自增主键
  • mybatis-3.4.6 事务管理


开篇

  • 这个系列是基于mybatis-3.4.6版本的源码解析，这篇文章是梳理基于SqlSessionFactory的mybatis的整体执行流程，文章更侧重于整体流程的梳理。
  • 在mybatis-3.4.6 SQL执行流程的文章中已经分析了SQL执行的流程并定位最终有SqlSession来完成最后的SQL执行过程。
  • 在这篇文章中具体分析下SqlSession的执行过程。


JDBC执行Statement步骤

jdbc执行Statement的核心步骤，mybatis的流程大致如此。

// 驱动注册程序
Class.forName(com.mysql.jdbc.Driver);
// 获取连接对象
Connection conn = DriverManager.getConnection(url,user,password);
// 创建Statement对象
Statement stsm = conn.createStatement();
// 执行sql语句
stsm.executeUpdate(sql);
// 关闭连接
stsm.close();
conn.close();
  • 1、驱动注册程序。
  • 2、获取连接对象。
  • 3、创建Statement对象。
  • 4、执行sql语句。
  • 5、关闭连接。


SqlSession执行过程

mybatis-3.4.6 SqlSession执行过程_第1张图片
SqlSession执行过程
  • DefaultSqlSession执行CachingExecutor，CachingExecutor执行SimpleExecutor，最终执行流程都通过SimpleExecutor来执行。
  • SimpleExecutor核心在于获取connection，初始化statement对象，格式化查询SQL并通过PreparedStatementHandler执行statement。
  • PreparedStatementHandler是真正执行SQL查询和结果处理的核心类。
  • DefaultResultHandler负责处理查询结果的逻辑。
  • SimpleExecutor的prepareStatement内部创建connection和statement的核心逻辑。


MapperMethod

public class MapperMethod {

  private final SqlCommand command;
  private final MethodSignature method;

  public MapperMethod(Class mapperInterface, Method method, Configuration config) {
    this.command = new SqlCommand(config, mapperInterface, method);
    this.method = new MethodSignature(config, mapperInterface, method);
  }

  public Object execute(SqlSession sqlSession, Object[] args) {
    Object result;
    switch (command.getType()) {
      case INSERT: {
        Object param = method.convertArgsToSqlCommandParam(args);
        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()) {
          executeWithResultHandler(sqlSession, args);
          result = null;
        } else if (method.returnsMany()) {
          result = executeForMany(sqlSession, args);
        } else if (method.returnsMap()) {
          result = executeForMap(sqlSession, args);
        } else if (method.returnsCursor()) {
          result = executeForCursor(sqlSession, args);
        } else {
          Object param = method.convertArgsToSqlCommandParam(args);
          result = sqlSession.selectOne(command.getName(), param);
          if (method.returnsOptional()
              && (result == null || !method.getReturnType().equals(result.getClass()))) {
            result = Optional.ofNullable(result);
          }
        }
        break;
      case FLUSH:
        result = sqlSession.flushStatements();
        break;
      default:
        throw new BindingException("Unknown execution method for: " + command.getName());
    }
    if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
      throw new BindingException("Mapper method '" + command.getName()
          + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
    }
    return result;
  }


  private void executeWithResultHandler(SqlSession sqlSession, Object[] args) {
    MappedStatement ms = sqlSession.getConfiguration().getMappedStatement(command.getName());
  
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      sqlSession.select(command.getName(), param, rowBounds, method.extractResultHandler(args));
    } else {
      sqlSession.select(command.getName(), param, method.extractResultHandler(args));
    }
  }

  private  Object executeForMany(SqlSession sqlSession, Object[] args) {
    List result;
    Object param = method.convertArgsToSqlCommandParam(args);
    if (method.hasRowBounds()) {
      RowBounds rowBounds = method.extractRowBounds(args);
      result = sqlSession.selectList(command.getName(), param, rowBounds);
    } else {
      result = sqlSession.selectList(command.getName(), param);
    }
    // issue #510 Collections & arrays support
    if (!method.getReturnType().isAssignableFrom(result.getClass())) {
      if (method.getReturnType().isArray()) {
        return convertToArray(result);
      } else {
        return convertToDeclaredCollection(sqlSession.getConfiguration(), result);
      }
    }
    return result;
  }
}
  • MapperMethod的SqlCommand创建打通了Dao和Mapper.xml的映射关系，Mapper.xml在Configuration的对象中按照dao的interface+method维度保存了MappedStatement，而SqlCommand的创建就是根据dao的interface+method查询Configuration获得MappedStatement进行后续的所有操作。
  • 从MapperMethod的execute可以看出所有的SQL命令本质都是通过sqlSession来完成真正的执行。
  • 那么下一步核心就得研究下sqlSession的执行过程了。


SqlCommand

public class MapperMethod {

  public static class SqlCommand {

    private final String name;
    private final SqlCommandType type;

    public SqlCommand(Configuration configuration, Class mapperInterface, Method method) {
      final String methodName = method.getName();
      final Class declaringClass = method.getDeclaringClass();
      MappedStatement ms = resolveMappedStatement(mapperInterface, methodName, declaringClass,
          configuration);
      if (ms == null) {
        if (method.getAnnotation(Flush.class) != null) {
          name = null;
          type = SqlCommandType.FLUSH;
        } else {
        }
      } else {
        name = ms.getId();
        type = ms.getSqlCommandType();
        if (type == SqlCommandType.UNKNOWN) {
          throw new BindingException("Unknown execution method for: " + name);
        }
      }
    }

    private MappedStatement resolveMappedStatement(Class mapperInterface, String methodName,
        Class declaringClass, Configuration configuration) {
      // 根据interface + method去查找对应的MappedStatement对象
      String statementId = mapperInterface.getName() + "." + methodName;
      if (configuration.hasStatement(statementId)) {
        return configuration.getMappedStatement(statementId);
      } else if (mapperInterface.equals(declaringClass)) {
        return null;
      }
      for (Class superInterface : mapperInterface.getInterfaces()) {
        if (declaringClass.isAssignableFrom(superInterface)) {
          MappedStatement ms = resolveMappedStatement(superInterface, methodName,
              declaringClass, configuration);
          if (ms != null) {
            return ms;
          }
        }
      }
      return null;
    }
  }
}
  • resolveMappedStatement根据mapper.xml文件的namespace的namespace + 对应的执行的method去查找对应的MappedStatement对象。


DefaultSqlSession

public class DefaultSqlSession implements SqlSession {

  private final Configuration configuration;
  private final Executor executor;

  private final boolean autoCommit;
  private boolean dirty;
  private List> cursorList;

  public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
    this.configuration = configuration;
    this.executor = executor;
    this.dirty = false;
    this.autoCommit = autoCommit;
  }

  public  List selectList(String statement, Object parameter, RowBounds rowBounds) {
    try {
      // 查询配置xml解析后的MappedStatement对象
      // statement为interface+method维度，如cn.edu.example.mapper.UserMapper.getById
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }
}
  • DefaultSqlSession从configuration根据interface+method维度获取MappedStatement。
  • MappedStatement的注册本身包含interface+method和method两个维度的key。
  • DefaultSqlSession内部通过executor去执行SQL查询。


Executor

public interface Executor {

  ResultHandler NO_RESULT_HANDLER = null;

  int update(MappedStatement ms, Object parameter) throws SQLException;

   List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;

   List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;

   Cursor queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;

  List flushStatements() throws SQLException;

  void commit(boolean required) throws SQLException;

  void rollback(boolean required) throws SQLException;

  CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);

  boolean isCached(MappedStatement ms, CacheKey key);

  void clearLocalCache();

  void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class targetType);

  Transaction getTransaction();

  void close(boolean forceRollback);

  boolean isClosed();

  void setExecutorWrapper(Executor executor);

}
mybatis-3.4.6 SqlSession执行过程_第2张图片
Executor
  • Executor的核心类关系如上图所示，核心接口也如上所示。


CachingExecutor

public class CachingExecutor implements Executor {
  // delegate为SimpleExecutor对象
  private final Executor delegate;
  private final TransactionalCacheManager tcm = new TransactionalCacheManager();

  public CachingExecutor(Executor delegate) {
    this.delegate = delegate;
    delegate.setExecutorWrapper(this);
  }

  @Override
  public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

  @Override
  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) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        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);
  }
}
  • DefaultSqlSession通过CachingExecutor去执行，在CachingExecutor内部通过SimpleExecutor执行逻辑。
  • CachingExecutor的delegate为SimpleExecutor对象，真正是通过SimpleExecutor去执行query。


SimpleExecutor

public abstract class BaseExecutor implements Executor {

  public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {

    List list;
    try {
      queryStack++;
      list = resultHandler == null ? (List) localCache.getObject(key) : null;
      // 核心逻辑先取缓存，没有再从DB进行获取
      if (list != null) {
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        // 从mysql进行查询
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }

    return list;
  }

  private  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }
}
  • SimpleExecutor的query调用父类的BaseExecutor的queryFromDatabase，进而调用SimpleExecutor自身的doQuery来实现查询。
public class SimpleExecutor extends BaseExecutor {

  @Override
  public  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      // 创建RoutingStatementHandler对象
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      // 核心逻辑是创建mysql的stmt对象，内部包含建立connection和创建stmt对象
      stmt = prepareStatement(handler, ms.getStatementLog());
      // 执行query操作
      return handler.query(stmt, resultHandler);
    } finally {
      closeStatement(stmt);
    }
  }

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    // 获取mysql连接对象
    Connection connection = getConnection(statementLog);
    // 初始化mysql的statement对象
    stmt = handler.prepare(connection, transaction.getTimeout());
    // 初始化mysql的statement的查询参数
    handler.parameterize(stmt);
    return stmt;
  }
}


public class Configuration {

  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }
  • SimpleExecutor的configuration.newStatementHandler返回RoutingStatementHandler对象。
  • prepareStatement的负责最核心的connection的建立以及statement的生成，所有的SQL执行是通过statement来完成操作的。
  • prepareStatement核心对statement的查询语句进行了格式化，填充请求参数。


RoutingStatementHandler

public class RoutingStatementHandler implements StatementHandler {

  private final StatementHandler delegate;

  public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

    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());
    }
  }

  public  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
    // 本质上是PreparedStatementHandler对象
    return delegate.query(statement, resultHandler);
  }
}
  • RoutingStatementHandler针对StatementHandler进行二次封装，内部是通过StatementHandler来实现query查询。
  • 这里暂时通过PreparedStatementHandler来进行举例。


PreparedStatementHandler

public class PreparedStatementHandler extends BaseStatementHandler {

  public  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
    // mysql的PreparedStatement对象并执行
    PreparedStatement ps = (PreparedStatement) statement;
    // 执行PreparedStatement
    ps.execute();
    // 通过handleResultSets处理查询结果
    return resultSetHandler. handleResultSets(ps);
  }

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

    final List multipleResults = new ArrayList();

    int resultSetCount = 0;
    ResultSetWrapper rsw = getFirstResultSet(stmt);

    List resultMaps = mappedStatement.getResultMaps();
    int resultMapCount = resultMaps.size();
    validateResultMapsCount(rsw, resultMapCount);
    while (rsw != null && resultMapCount > resultSetCount) {
      ResultMap resultMap = resultMaps.get(resultSetCount);
      handleResultSet(rsw, resultMap, multipleResults, null);
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }

    String[] resultSets = mappedStatement.getResultSets();
    if (resultSets != null) {
      while (rsw != null && resultSetCount < resultSets.length) {
        ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
        if (parentMapping != null) {
          String nestedResultMapId = parentMapping.getNestedResultMapId();
          ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
          handleResultSet(rsw, resultMap, null, parentMapping);
        }
        rsw = getNextResultSet(stmt);
        cleanUpAfterHandlingResultSet();
        resultSetCount++;
      }
    }

    return collapseSingleResultList(multipleResults);
  }
}
 
 
     
  
  • PreparedStatementHandler的内部执行流程是执行statement并通过handleResultSets来处理结果。
    •  
 
 
 

 
 
获取connection的过程
 
 
public class SimpleExecutor extends BaseExecutor {

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    stmt = handler.prepare(connection, transaction.getTimeout());
    handler.parameterize(stmt);
    return stmt;
  }
}

public abstract class BaseExecutor implements Executor {

  protected Connection getConnection(Log statementLog) throws SQLException {
    Connection connection = transaction.getConnection();
    if (statementLog.isDebugEnabled()) {
      return ConnectionLogger.newInstance(connection, statementLog, queryStack);
    } else {
      return connection;
    }
  }
}

 
 
public class JdbcTransaction implements Transaction {

  public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {
    dataSource = ds;
    level = desiredLevel;
    autoCommmit = desiredAutoCommit;
  }

  @Override
  public Connection getConnection() throws SQLException {
    if (connection == null) {
      openConnection();
    }
    return connection;
  }

  protected void openConnection() throws SQLException {
     // 通过JDBC的 getConnection来获取connection连接对象
    connection = dataSource.getConnection();
    if (level != null) {
      connection.setTransactionIsolation(level.getLevel());
    }
    setDesiredAutoCommit(autoCommmit);
  }
}

 
 
     
  
  • connection的openConnection本质是通过dataSource.getConnection()来实现连接的获取。
    •  
 
 
 

 
 
获取statetment的过程
 
 
public abstract class BaseStatementHandler implements StatementHandler {

  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      statement = instantiateStatement(connection);
      setStatementTimeout(statement, transactionTimeout);
      setFetchSize(statement);
      return statement;
    } catch (SQLException e) {
      closeStatement(statement);
      throw e;
    } catch (Exception e) {
      closeStatement(statement);
      throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
    }
  }
}


public class PreparedStatementHandler extends BaseStatementHandler {

  @Override
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    String sql = boundSql.getSql();
    if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
      String[] keyColumnNames = mappedStatement.getKeyColumns();
      if (keyColumnNames == null) {
        return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
      } else {
        return connection.prepareStatement(sql, keyColumnNames);
      }
    } else if (mappedStatement.getResultSetType() != null) {
      return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    } else {

      return connection.prepareStatement(sql);
    }
  }
}

 
 
     
  
  • statetment的获取本质是通过connection.prepareStatement去实现，中间无非增加了一些proxy的设置。
    •  
 
 
 

 
 
参考文章
 
 
     
  
  • 源码参考
    •  
  
  • mybatis官网介绍
    •  
  
  • 深入理解mybatis原理
    •  
  
  • Mybatis3.4.x技术内幕
    •  
  
  • mybatis 3.x源码深度解析与最佳实践
    •  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(mybatis-3.4.6 SqlSession执行过程)

        

            

                
    
                    
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现
                        Lenyiin
C++修炼全景指南技术指南c++数据结构stl
                        
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
    
                    
    • 
                    
  • 重载new，delete ， RTTI，类成员指针
                        森龙安
C++c++
                        
    重载new，delete执行过程重载new，delete和普通的运算符重载不同，并非重载new，delete的行为，而是改变内存分配的方式，将对象放置在特定的内存空间中new运算符操作：调用STL标准模板库的重载operatornew或operatornew[]函数，分配足够大的未命名内存运行相应构造函数返回指向对象的指针delete运算符操作：运行相应折构函数、调用STL标准模板库的重载oper
    
                    
    • 
                    
  • 服了我的一根筋
                        公木白

                        
    以前朋友说我一根筋，还有的说我是棒槌，实心眼的，听了我呵呵一笑，照常行事。年龄越大，越苦恼于我的一根筋，在我的思维模式里，所有的事情都是直线，点对点，没有曲折，没有迂回，对事的态度非黑及白，没有灰色地带。如果想好了一件事，脑子里只有这一件事，或者说遇事想好了解决办法，即使在执行过程中有更好的，也会自动忽略，还一直初在原定思维里。这种情况不只发生一两次，遇事不知变通，也不知道拐弯，总是过后才发觉本可
    
                    
    • 
                    
  • Golang channel 死锁
                        羊城程序猿
golanggolang
                        
    死锁是指两个或两个以上的协程的执行过程中，由于竞争资源或由于彼此通信而造成的一种阻塞的现象，若无外力作用，他们将无法推进下去,以下是总结出来的几种死锁情况。1.死锁1：一个通道在一个主go程里同时进行读和写2.死锁2：go程开启之前使用通道3.死锁3：通道1中调用了通道2，通道2中调用通道14.死锁4：直接读取空channel的死锁5.死锁5：超过channel缓存继续写入数据导致死锁6.向已关闭
    
                    
    • 
                    
  • [Golang] goroutine
                        沉着冷静2024
Golanggolang后端
                        
    [Golang]goroutine文章目录[Golang]goroutine并发进程和线程协程goroutine概述如何使用goroutine并发进程和线程谈到并发，大多都离不开进程和线程，什么是进程、什么是线程？进程可以这样理解：进程就是运行着的程序，它是程序在操作系统的一次执行过程，是一个程序的动态概念，进程是操作系统分配资源的基本单位。线程可以这样理解：线程是一个进程的执行实体，它是比进程粒
    
                    
    • 
                    
  • 一条sql是如何执行的详解
                        听忆.
轻松拿捏【面试干货】sql数据库
                        
    一条sql是如何执行的详解1.SQL解析（Parsing）2.查询重写（QueryRewrite）3.查询规划（QueryPlanning）4.查询执行（QueryExecution）5.结果返回示例：查询执行流程总结边走、边悟迟早会好一条SQL查询在PostgreSQL（以及大多数关系型数据库）中的执行过程可以分为多个阶段。每个阶段都对应特定的任务，从SQL解析到最终获取查询结果。以下是SQL查
    
                    
    • 
                    
  • RACCommand
                        frankisbaby

                        
    RACCommand：RAC中用于处理事件的类，可以把事件如何处理，事件中的数据如何传递包装到这个类中，它可以很方便的监控事件的执行过程。使用场景：监听按钮点击事件，网络请求；使用步骤：1.创建命令：RACCommand不能返回一个空的信号：RACCommand*command=[[RACCommandalloc]initWithSignalBlock:^RACSignal*_Nonnull(id
    
                    
    • 
                    
  • 【Starrocks】建表篇Fe源码解析
                        数算七弦
Starrocks大数据
                        
    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
    
                    
    • 
                    
  • vue3从精通到入门15：内置组件之Suspense
                        无名H
vue3前端javascript开发语言vue.jshtml前端框架
                        
    是一个内置组件，它允许你在组件加载时显示一个备用内容（fallbackcontent），直到组件真正渲染完成。这对于处理异步组件加载特别有用，可以提供更好的用户体验，防止用户看到未完成的界面或空白的加载状态。我们了解Suspense之前，先了解下什么是异步依赖和异步组件。异步依赖异步依赖通常指的是在组件加载或执行过程中需要异步获取的数据或功能。这些数据或功能可能来自网络请求、其他组件的异步加载，或
    
                    
    • 
                    
  • 高效时间管理清单来了！你还在拖延吗？
                        思维导图小铺

                        
    别再徒劳挣扎了，有了这三个清单，高效不在话下↓↓↓关于『认知负担』你必须要知道的：工作、学习中，很多人有做“todolist”的习惯，简单讲就是把待办事务整理成清单格式，然后去完成。但有一个普遍现象是，大家一开始完成的好好的，没坚持多久就抛诸脑后了。造成这个的原因，无非是执行过程中遇到了阻力，或者动力削减了。而这两点都跟我们做的计划有关，简单讲，就是任务设置的太复杂。试想，简单的事情做起来毫不费力
    
                    
    • 
                    
  • Unity协程搭配队列开发Tips弹窗模块
                        傻Q爱
Unity技术unityjava游戏引擎
                        
    概述在Unity游戏开发过程中，提示系统是提升用户体验的重要组成部分。一个设计良好的提示窗口不仅能及时传达信息给玩家，还应当做到不干扰游戏流程。本文将探讨如何使用Unity的协程（Coroutine）配合队列（Queue）数据结构来构建一个高效且可扩展的Tips弹窗模块。技术模块介绍1.Unity协程（Coroutines）协程是Unity中的一种特殊函数类型，允许异步操作的实现。它能够在执行过程
    
                    
    • 
                    
  • ssm——整合，前端页面设计，分页
                        2401_86367399
面试辅导大厂内推前端java开发语言
                        
    empMapper.updateEmpById(m);}//用于批量的插入数据@TestpublicvoidinsertDeptByBATCH(){DeptMapperOCM=sqlSession.getMapper(DeptMapper.class);for(inti=0;iindex.jsp页面发送出查询信息列表的请求->EmpController来接受请求，然后查询出员工数据->跳转到lis
    
                    
    • 
                    
  • 麦肯锡内部团队的沟通管理方法
                        简丹来说

                        
    项目图纸准备交付了，大家都把自己设计的部分提交给主管进行审核。主管发现小李的图纸中，有多处设备图选用错误，导致相关部分的配套设计也不正确。询问小李，小李说设备是按合同做的，后来更换设备的事他并不知道，没有人通知他。原来，在项目执行过程中，客户提出了一些修改要求。新任项目经理小林也把修改部分通知了相关负责人，他以为调整前后设备型号变化不大，对工艺可能没多大影响，因而只通知了设备和制造部门，并没有提醒
    
                    
    • 
                    
  • MyBatis 一级缓存失效场景的深入分析
                        胡耀超
java面试常见问题mybatis缓存javaspring
                        
    MyBatis是Java开发中常用的数据持久化框架，它通过SQL映射文件将Java对象与数据库进行映射。在提升性能方面，MyBatis引入了一级缓存和二级缓存。其中，一级缓存是作用于SqlSession范围内的缓存，其默认是开启的，可以有效减少数据库查询次数。但是，在一些特定的操作和场景下，一级缓存会失效。本文将对一级缓存的失效场景进行全面总结、对比，并通过代码案例进行详细解释。一级缓存的原理一级
    
                    
    • 
                    
  • 接口测试框架实战-JSON 请求与响应断言
                        蜀山客e

                        
    数据驱动就是通过数据的改变驱动自动化测试的执行，最终引起测试结果的改变。简单来说，就是参数化在自动化测试中的应用。测试过程中使用数据驱动的优势主要体现在以下几点：1、提高代码复用率，相同的测试逻辑只需编写一条测试用例，就可以被多条测试数据复用，提高了测试代码的复用率，同时提高了测试代码的编写效率。2、异常排查效率高，测试框架依据测试数据，每条数据生成一条测试用例，用例执行过程相互隔离。如果其中一条
    
                    
    • 
                    
  • 2021-10-17 心里慌乱的一个周末
                        小白的姐姐

                        
    我的时间确实是我自己的，但是我不知道如何安排。今天早上我给自己制定了计划，包括要完成的几件事情，但是没有指定完成时间，结果导致自己在实际执行过程中手忙脚乱。出现的问题或者说让我慌乱的原因主要有以下几点：1.还有几件事情要做，但是不知道先做哪个再做哪个2.每一个事情不知道需要多长时间3.担心事情做不完难点在于知道事情完成的大概时间对应方法：1.每天记录自己做事情完成的时间（正好每天写日记，可以记录下
    
                    
    • 
                    
  • 总结函数相关知识
                        你会发光哎u
JavaScript高级学习javascript前端开发语言
                        
    这里写目录标题1.函数的特性声明调用参数参数默认值返回值属性方法arguments剩余参数（`rest`）作用域原型`this`指向执行过程2.特殊的函数`with`函数`eval`函数apply/call/bind函数纯函数箭头函数立即执行函数`IIFE`高阶函数递归函数组合函数柯里化函数概念优势自动柯里化类和构造函数JavaScript是支持函数式编程的，在JavaScript中函数是一等公民
    
                    
    • 
                    
  • 服务器每秒钟执行命令数量是什么_Redis的内部运作机制
                        weixin_39753791
服务器每秒钟执行命令数量是什么
                        
    本文将分五个部分来分析和总结Redis的内部机制，分别是：Redis数据库、Redis客户端、Redis事件、Redis服务器的初始化步骤、Redis命令的执行过程。首先介绍一下Redis服务器的状态结构。Redis使用一个类型为“redisServer”的数据结构来保存整个Redis服务器的状态(每个属性按照即将讲解的顺序进行排序)：structredisServer{intdbnum;//服务
    
                    
    • 
                    
  • 第五章 SqlSession 的创建过程
                        flying jiang
MyBatis3源码深度解析javatomcatmybatis
                        
    在MyBatis3中，SqlSession的创建过程涉及到对MyBatis配置文件的解析，这通常是通过XPath（XMLPathLanguage）来完成的。XPath是一种在XML文档中查找信息的语言，MyBatis使用它来解析配置文件（如mybatis-config.xml）中的元素和属性。以下是SqlSession创建过程中XPath使用的简要概述：读取配置文件：MyBatis首先需要读取其配
    
                    
    • 
                    
  • 13. 说说 MyBatis 的缓存机制？
                        这孩子叫逆
Mybatis笔记mybatisjavaspring
                        
    MyBatis提供了一级缓存和二级缓存两种缓存机制，用于提高应用程序的性能，减少数据库的访问次数。缓存机制是MyBatis的一个重要特性，通过缓存可以在一定程度上减少对数据库的访问，从而提高查询性能。1.一级缓存（LocalCache）作用范围：一级缓存是MyBatis默认开启的缓存机制，作用于SqlSession级别。特点：生命周期：一级缓存的生命周期与SqlSession相同。在同一个SqlS
    
                    
    • 
                    
  • 插入排序（dart实现）
                        锦鲤跃龙

                        
    插入排序[toc]把数字插入合适的位置1.执行流程在执行过程中，插入排序会讲序列分为两部分头部是已经排好序的，尾部是待排序的从头开始扫描每一个元素每当扫描到一个原生，就将它插入到头部合适的位置，使得头部数据依然保持有序2.dart代码import'sort.dart';classInsertSort>extendsSort{@overridesort(){for(varbegin=1;begin0
    
                    
    • 
                    
  • 微机原理——从基础到实践的全面解析
                        小朱在敲代码
软件工程
                        
    文章目录微机原理——从基础到实践的全面解析1.微型计算机的基本组成1.1.CPU的内部结构2.指令的执行过程2.1.指令的类型3.存储器系统3.1.RAM与ROM的区别3.2.存储器的工作原理4.中断系统与I/O接口4.1.中断的工作过程4.2.输入输出（I/O）设备与接口5.微机原理在实际中的应用5.1.嵌入式系统中的微机5.2.物联网中的微机应用总结微机原理——从基础到实践的全面解析微机原理是
    
                    
    • 
                    
  • Java异常机制01：初识异常
                        耳东er
#Java异常机制java
                        
    一、什么是异常什么是异常:程序执行过程中的不正常情况异常的作用:增强程序的健壮性java提供异常处理机制有什么用:——Java语言是很完善的语言，提供了异常的处理方式，程序在执行过程中出现了不正常情况，Java把该异常信息打印输出到控制台，供程序员参考。程序员看到异常信息之后，可以对程序进行修改，让程序更加健壮。异常指程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等异常
    
                    
    • 
                    
  • Redis 事务：支持回滚吗？深入解析
                        我爱娃哈哈
Redisredisjavabootstrap
                        
    今天我们要来探讨一个关于Redis事务的重要问题：Redis事务支持回滚吗？这个问题在Redis的使用中经常被提及，对于正确理解和使用Redis事务至关重要。那么，让我们一起深入解析这个问题吧！一、Redis事务简介在了解Redis事务是否支持回滚之前，我们先来简单回顾一下Redis事务的基本概念。Redis事务是一组命令的集合，这些命令会按照顺序依次执行，并且在执行过程中不会被其他客户端的命令打
    
                    
    • 
                    
  • chapter03 流程语句 知识点Note
                        月下绯烟
Java开发语言java
                        
    @TOC分支结构if-else和switch-caseswitch(表达式){case常量值1:语句块1;//break;case常量值2:语句块2;//break;//...[default:语句块n+1;break;]}switch-case执行过程：第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。第2步：执
    
                    
    • 
                    
  • 二叉树的先序遍历递归执行过程
                        peterLC
Java二叉树
                        
    一、流程先访问根节点，再访问左子树，最后访问右子树。以此类推二、具体代码publicclassTest{staticclassNode{publiccharval;publicNodeleft;publicNoderight;publicNode(charval){this.val=val;}}staticNodebuild(){//构建一棵树，返回数的根节点。NodeA=newNode('A')
    
                    
    • 
                    
  • 2024年大数据高频面试题(下篇）
                        猿与禅
Java架构师面试大数据面试scala即席查询分桶调度系统数据倾斜
                        
    文章目录Scala数据类型函数式编程闭包函数柯里化面向对象样例类对象与伴生对象特质(trait)模式匹配隐式转换即席查询KylinKylin特点Kylin工作原理核心算法Kylin总结Kylin的优点什么场景用KylinKylin的缺点Impala什么是ImpalaImpala为什么快FrontendBackendImpala总结：Presto什么是PrestoPresto的执行过程Presto总
    
                    
    • 
                    
  • 【Java】已解决：javax.script.ScriptException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景场景示例：代码片段：二、可能出错的原因三、错误代码示例错误分析：四、正确代码示例代码改进说明：五、注意事项在Java开发中，javax.script.ScriptException是一种常见的异常类型，通常出现在使用脚本引擎执行动态脚本代码时。该异常表明在脚本执行过程中发生了错误。本文将详细分析ScriptException的背景、可能的原因、错误代码示例、正确的代码示例，
    
                    
    • 
                    
  • Java Virtual Machine One
                        LongProgrammer
jvm
                        
    jvm结构类加载子系统：类加载器验证准备解析数据运行时数据区：1.方法区类信息方法信息常量池2.堆体系:线程共享区域堆存放new的对象3.栈线程私有的存放线程执行过程的方法信息（存储单位为栈帧）4.程序计时器执行线程的行号计时器5.本地方法栈native方法栈执行引擎：将二进制的指令解释给操作系统栈虚拟栈:存储每个线程的栈结构，线程私有，栈中存储的元素是栈帧每个栈帧存储一个线程的方法信息，方法内部
    
                    
    • 
                    
  • 软件测试计划包括哪些内容?专业第三方软件测试机构推荐
                        卓码测评
软件测试
                        
    在当今软件开发过程中，软件测试计划作为确保软件产品质量的关键环节，不仅对开发团队至关重要，也对项目的成功实施起到不可或缺的作用。软件测试计划为测试活动提供了系统的框架和指导，使团队能够合理安排测试工作，保障软件的高质量交付。一、软件测试计划的定义软件测试计划是一份详细文档，描述了测试活动的策略、目标、资源、时间安排和执行过程。它明确了测试的范围、方法以及各种测试资源的分配，确保各方对测试工作有一致
    
                    
    • 
                                
  • Nginx负载均衡
                                    510888780
nginx应用服务器
                                    
    Nginx负载均衡一些基础知识: 
 
nginx 的 upstream目前支持 4 种方式的分配 
1)、轮询（默认） 
      每个请求按时间顺序逐一分配到不同的后端服务器，如果后端服务器down掉，能自动剔除。 
2)、weight 
      指定轮询几率，weight和访问比率成正比
    
                                
    • 
                                
  • RedHat 6.4 安装 rabbitmq
                                    bylijinnan
erlangrabbitmqredhat
                                    
    在 linux 下安装软件就是折腾，首先是测试机不能上外网要找运维开通，开通后发现测试机的 yum 不能使用于是又要配置 yum 源，最后安装 rabbitmq 时也尝试了两种方法最后才安装成功 
 
机器版本： 
 
[root@redhat1 rabbitmq]# lsb_release
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core
    
                                
    • 
                                
  • FilenameUtils工具类
                                    eksliang
FilenameUtilscommon-io
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2217081 一、概述 
这是一个Java操作文件的常用库，是Apache对java的IO包的封装，这里面有两个非常核心的类FilenameUtils跟FileUtils，其中FilenameUtils是对文件名操作的封装;FileUtils是文件封装，开发中对文件的操作，几乎都可以在这个框架里面找到。 非常的好用。 
    
                                
    • 
                                
  • xml文件解析SAX
                                    不懂事的小屁孩
xml
                                    
    xml文件解析:xml文件解析有四种方式， 
1.DOM生成和解析XML文档(SAX是基于事件流的解析) 
2.SAX生成和解析XML文档(基于XML文档树结构的解析) 
3.DOM4J生成和解析XML文档 
4.JDOM生成和解析XML  
本文章用第一种方法进行解析，使用android常用的DefaultHandler 
 
 
import org.xml.sax.Attributes;

    
                                
    • 
                                
  • 通过定时任务执行mysql的定期删除和新建分区，此处是按日分区
                                    酷的飞上天空
mysql
                                    
    使用python脚本作为命令脚本，linux的定时任务来每天定时执行 
  
#!/usr/bin/python
# -*- coding: utf8 -*-
import pymysql
import datetime
import calendar

#要分区的表
table_name = 'my_table'
#连接数据库的信息
host,user,passwd,db = 
    
                                
    • 
                                
  • 如何搭建数据湖架构？听听专家的意见
                                    蓝儿唯美
架构
                                    
    Edo Interactive在几年前遇到一个大问题：公司使用交易数据来帮助零售商和餐馆进行个性化促销，但其数据仓库没有足够时间去处理所有的信用卡和借记卡交易数据 
 “我们要花费27小时来处理每日的数据量，”Edo主管基础设施和信息系统的高级副总裁Tim Garnto说道：“所以在2013年，我们放弃了现有的基于PostgreSQL的关系型数据库系统，使用了Hadoop集群作为公司的数
    
                                
    • 
                                
  • spring学习——控制反转与依赖注入
                                    a-john
spring
                                    
           控制反转（Inversion of Control，英文缩写为IoC）是一个重要的面向对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心。 控制反转一般分为两种类型，依赖注入（Dependency Injection，简称DI）和依赖查找（Dependency Lookup）。依赖注入应用比较广泛。 
  

    
                                
    • 
                                
  • 用spool+unixshell生成文本文件的方法
                                    aijuans
xshell
                                    
    例如我们把scott.dept表生成文本文件的语句写成dept.sql,内容如下:  
　　set pages 50000; 
　　set lines 200; 
　　set trims on; 
　　set heading off; 
　　spool /oracle_backup/log/test/dept.lst; 
　　select deptno||','||dname||','||loc 
    
                                
    • 
                                
  • 1、基础--名词解析(OOA/OOD/OOP)
                                    asia007
学习基础知识
                                    
    OOA:Object-Oriented Analysis（面向对象分析方法） 
是在一个系统的开发过程中进行了系统业务调查以后，按照面向对象的思想来分析问题。OOA与结构化分析有较大的区别。OOA所强调的是在系统调查资料的基础上，针对OO方法所需要的素材进行的归类分析和整理，而不是对管理业务现状和方法的分析。 
　　OOA（面向对象的分析）模型由5个层次（主题层、对象类层、结构层、属性层和服务层）
    
                                
    • 
                                
  • 浅谈java转成json编码格式技术
                                    百合不是茶
json编码java转成json编码
                                    
    json编码;是一个轻量级的数据存储和传输的语言 
   
   在java中需要引入json相关的包,引包方式在工程的lib下就可以了 
  
JSON与JAVA数据的转换（JSON 即 JavaScript Object Natation，它是一种轻量级的数据交换格式，非 
  
常适合于服务器与 JavaScript 之间的数据的交
    
                                
    • 
                                
  • web.xml之Spring配置(基于Spring+Struts+Ibatis)
                                    bijian1013
javaweb.xmlSSIspring配置
                                    
    指定Spring配置文件位置 
<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>
			/WEB-INF/spring-dao-bean.xml,/WEB-INF/spring-resources.xml,
			/WEB-INF/
    
                                
    • 
                                
  • Installing SonarQube（Fail to download libraries from server）
                                    sunjing
InstallSonar
                                    
    1.  Download and unzip the SonarQube distribution  
2.  Starting the Web Server 
The default port is "9000" and the context path is "/". These values can be changed in &l
    
                                
    • 
                                
  • 【MongoDB学习笔记十一】Mongo副本集基本的增删查
                                    bit1129
mongodb
                                    
    一、创建复本集 
  
假设mongod,mongo已经配置在系统路径变量上，启动三个命令行窗口，分别执行如下命令： 
  
mongod --port 27017 --dbpath  data1 --replSet rs0

mongod --port 27018 --dbpath  data2 --replSet rs0

mongod --port 27019 -
    
                                
    • 
                                
  • Anychart图表系列二之执行Flash和HTML5渲染
                                    白糖_
Flash
                                    
    今天介绍Anychart的Flash和HTML5渲染功能 
  
 
 HTML5 
 
Anychart从6.0第一个版本起，已经逐渐开始支持各种图的HTML5渲染效果了，也就是说即使你没有安装Flash插件，只要浏览器支持HTML5，也能看到Anychart的图形（不过这些是需要做一些配置的）。 
这里要提醒下大家，Anychart6.0版本对HTML5的支持还不算很成熟，目前还处于
    
                                
    • 
                                
  • Laravel版本更新异常4.2.8-> 4.2.9 Declaration of ... CompilerEngine ... should be compa
                                    bozch
laravel
                                    
    昨天在为了把laravel升级到最新的版本，突然之间就出现了如下错误： 
ErrorException thrown with message "Declaration of Illuminate\View\Engines\CompilerEngine::handleViewException() should be compatible with Illuminate\View\Eng
    
                                
    • 
                                
  • 编程之美-NIM游戏分析-石头总数为奇数时如何保证先动手者必胜
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;
import java.util.Random;

public class Nim {

	/**编程之美 NIM游戏分析
问题：
有N块石头和两个玩家A和B，玩家A先将石头随机分成若干堆，然后按照BABA...的顺序不断轮流取石头，
能将剩下的石头一次取光的玩家获胜，每次取石头时，每个玩家只能从若干堆石头中任选一堆，
    
                                
    • 
                                
  • lunce创建索引及简单查询
                                    chengxuyuancsdn
查询创建索引lunce
                                    
    import java.io.File;
import java.io.IOException;

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.document.Docume
    
                                
    • 
                                
  • [IT与投资]坚持独立自主的研究核心技术
                                    comsci
it
                                    
     
 
       和别人合作开发某项产品....如果互相之间的技术水平不同,那么这种合作很难进行,一般都会成为强者控制弱者的方法和手段..... 
 
 
       所以弱者,在遇到技术难题的时候,最好不要一开始就去寻求强者的帮助,因为在我们这颗星球上,生物都有一种控制其
    
                                
    • 
                                
  • flashback transaction闪回事务查询
                                    daizj
oraclesql闪回事务
                                    
       
闪回事务查询有别于闪回查询的特点有以下3个： 
 
（1）其正常工作不但需要利用撤销数据，还需要事先启用最小补充日志。 
 
（2）返回的结果不是以前的“旧”数据，而是能够将当前数据修改为以前的样子的撤销SQL（Undo SQL）语句。 
 
（3）集中地在名为flashback_transaction_query表上查询，而不是在各个表上通过“as of”或“vers
    
                                
    • 
                                
  • Java I/O之FilenameFilter类列举出指定路径下某个扩展名的文件
                                    游其是你
FilenameFilter
                                    
    这是一个FilenameFilter类用法的例子，实现的列举出“c:\\folder“路径下所有以“.jpg”扩展名的文件。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23   24   25   26   27   28  
    
                                
    • 
                                
  • C语言学习五函数，函数的前置声明以及如何在软件开发中合理的设计函数来解决实际问题
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int f(void)		//括号中的void表示该函数不能接受数据，int表示返回的类型为int类型
{
	return 10;	//向主调函数返回10
}

void g(void)	//函数名前面的void表示该函数没有返回值
{
	//return 10;	//error 与第8行行首的void相矛盾
}

in
    
                                
    • 
                                
  • 今天在测试环境使用yum安装，遇到一个问题： Error: Cannot retrieve metalink for repository: epel. Pl
                                    dcj3sjt126com
centos
                                    
    今天在测试环境使用yum安装，遇到一个问题： 
Error: Cannot retrieve metalink for repository: epel. Please verify its path and try again 
  
处理很简单，修改文件“/etc/yum.repos.d/epel.repo”， 将baseurl的注释取消， mirrorlist注释掉。即可。 
&n
    
                                
    • 
                                
  • 单例模式
                                    shuizhaosi888
单例模式
                                    
    单例模式        懒汉式 
public class RunMain {

	/**
	 * 私有构造
	 */
	private RunMain() {
	}
	
    /**
     * 内部类，用于占位，只有
     */
	private static class SingletonRunMain {
		priv
    
                                
    • 
                                
  • Spring Security（09）——Filter
                                    234390216
Spring Security
                                    
    Filter 
目录 
1.1     Filter顺序 
1.2     添加Filter到FilterChain 
1.3     DelegatingFilterProxy 
1.4     FilterChainProxy 
1.5
    
                                
    • 
                                
  • 公司项目NODEJS实践0.1
                                    逐行分析JS源代码
mongodbnginxubuntunodejs
                                    
      
一、前言 
        前端如何独立用nodeJs实现一个简单的注册、登录功能，是不是只用nodejs+sql就可以了？其实是可以实现，但离实际应用还有距离，那要怎么做才是实际可用的。 
        网上有很多nod
    
                                
    • 
                                
  • java.lang.Math
                                    liuhaibo_ljf
javaMathlang
                                    
    System.out.println(Math.PI); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1.2)); 
System.out.println(Math.abs(1)); 
System.out.println(Math.abs(111111111)); 
System.out.println(Mat
    
                                
    • 
                                
  • linux下时间同步
                                    nonobaba
ntp
                                    
    今天在linux下做hbase集群的时候，发现hmaster启动成功了，但是用hbase命令进入shell的时候报了一个错误  PleaseHoldException: Master is initializing，查看了日志，大致意思是说master和slave时间不同步，没办法，只好找一种手动同步一下，后来发现一共部署了10来台机器，手动同步偏差又比较大，所以还是从网上找现成的解决方
    
                                
    • 
                                
  • ZooKeeper3.4.6的集群部署
                                    roadrunners
zookeeper集群部署
                                    
    ZooKeeper是Apache的一个开源项目，在分布式服务中应用比较广泛。它主要用来解决分布式应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步、集群管理、配置文件管理、同步锁、队列等。这里主要讲集群中ZooKeeper的部署。 
  
1、准备工作 
我们准备3台机器做ZooKeeper集群，分别在3台机器上创建ZooKeeper需要的目录。 
  
数据存储目录
    
                                
    • 
                                
  • Java高效读取大文件
                                    tomcat_oracle
java
                                    
    　　读取文件行的标准方式是在内存中读取，Guava 和Apache Commons IO都提供了如下所示快速读取文件行的方法：   　　Files.readLines(new File(path), Charsets.UTF_8);   　　FileUtils.readLines(new File(path));   　　这种方法带来的问题是文件的所有行都被存放在内存中，当文件足够大时很快就会导致
    
                                
    • 
                                
  • 微信支付api返回的xml转换为Map的方法
                                    xu3508620
xmlmap微信api
                                    
    举例如下： 
<xml> 
   <return_code><![CDATA[SUCCESS]]></return_code> 
   <return_msg><![CDATA[OK]]></return_msg> 
   <appid><
    
                                
    •