MyBatis源码解析(一)——构造篇

前言

好久不见，从上一篇文章过后，休整了两个月，又逢疫情特殊时期，天天宅在家里挺尸，真是见证了一个人可以懒惰到什么境界。好吧废话不多说了，今天会给大家分享我们常用的持久层框架——MyBatis的工作原理和源码解析。

说实话MyBatis是我第一个接触的持久层框架，在这之前我也没有用过Hibernate，从Java原生的Jdbc操作数据库之后就直接过渡到了这个框架上，当时给我的第一感觉是，有一个框架太方便了，举一个例子吧，我们在Jdbc操作的时候，对于对象的封装，我们是需要通过ResultSet.getXXX(index)来获取值，然后在通过对象的setXXX()方法进行手动注入，这种重复且无任何技术含量的工作一直以来都是被我们程序猿所鄙视的一环，而MyBatis就可以直接将我们的SQL查询出来的数据与对象直接进行映射然后直接返回一个封装完成的对象，这节省了程序猿大部分的时间，当然其实JdbcTemplate也可以做到，但是这里先不说。MyBatis的优点有非常多，当然这也只有同时使用过Jdbc和MyBatis之后，产生对比，才会有这种巨大的落差感，但这并不是今天要讨论的重点，今天的重心还是放在MyBatis是如何做到这些的。

对于MyBatis，给我个人的感受，其工作流程实际上分为两部分：第一，构建，也就是解析我们写的xml配置，将其变成它所需要的对象。第二，就是执行，在构建完成的基础上，去执行我们的SQL，完成与Jdbc的交互。而这篇的重点会先放在构建上。

Xml配置文件

玩过这个框架的同学都知道，我们在单独使用它的时候，会需要两个配置文件，分别是mybatis-config.xml和mapper.xml，在官网上可以直接看到，当然这里为了方便，我就直接将我的xml配置复制一份。

    
        select * from test WHERE id =#{id}
    

我们不难看出，在mybatis-config.xml这个文件主要是用于配置数据源、配置别名、加载mapper.xml，并且我们可以看到这个文件的节点中包含了一个，而这个mapper所指向的路径就是另外一个xml文件：DemoMapper.xml，而这个文件中写了我们查询数据库所用的SQL。

而，MyBatis实际上就是将这两个xml文件，解析成配置对象，在执行中去使用它。

解析

• MyBatis需要什么配置对象？

  虽然在这里我们并没有进行源码的阅读，但是作为一个程序猿，我们可以凭借日常的开发经验做出一个假设。假设来源于问题，那么问题就是：为什么要将配置和SQL语句分为两个配置文件而不是直接写在一起？

  是不是就意味着，这两个配置文件会被MyBatis分开解析成两个不同的Java对象？

  不妨先将问题搁置，进行源码的阅读。

• 环境搭建

  首先我们可以写一个最基本的使用MyBatis的代码，我这里已经写好了。

  public static void main(String[] args) throws Exception {
      String resource = "mybatis-config.xml";
      InputStream inputStream = Resources.getResourceAsStream(resource);
      //创建SqlSessionFacory
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
      /******************************分割线******************************/
      SqlSession sqlSession = sqlSessionFactory.openSession();
      //获取Mapper
      DemoMapper mapper = sqlSession.getMapper(DemoMapper.class);
      Map map = new HashMap<>();
      map.put("id","123");
      System.out.println(mapper.selectAll(map));
      sqlSession.close();
      sqlSession.commit();
    }
  

  看源码重要的一点就是要找到源码的入口，而我们可以从这几行程序出发，来看看构建究竟是在哪开始的。

  首先不难看出，这段程序显示通过字节流读取了mybatis-config.xml文件，然后通过SqlSessionFactoryBuilder.build()方法，创建了一个SqlSessionFactory（这里用到了工厂模式和构建者模式），前面说过，MyBatis就是通过我们写的xml配置文件，来构建配置对象的，那么配置文件所在的地方，就一定是构建开始的地方，也就是build方法。

• 构建开始

  进入build方法，我们可以看到这里的确有解析的意思,这个方法返回了一个SqlSessionFactory，而这个对象也是使用构造者模式创建的，不妨继续往下走。

    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
      try {
        //解析mybatis-config.xml
        //XMLConfigBuilder  构造者
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        //parse(): 解析mybatis-config.xml里面的节点
        return build(parser.parse());
      } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
      } finally {
        ErrorContext.instance().reset();
        try {
          inputStream.close();
        } catch (IOException e) {
          // Intentionally ignore. Prefer previous error.
        }
      }
    }
  

  进入parse():

  public Configuration parse() {
    //查看该文件是否已经解析过
      if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
      }
      //如果没有解析过，则继续往下解析，并且将标识符置为true
      parsed = true;
      //解析节点
      parseConfiguration(parser.evalNode("/configuration"));
      return configuration;
    }
  

  注意parse的返回值，Configuration，这个似曾相识的单词好像在哪见过，是否与mybatis-config.xml中的节点有所关联呢？

  答案是肯定的，我们可以接着往下看。

  看到这里，虽然代码量还不是特别多，但是至少现在我们可以在大脑中得到一个大致的主线图，也如下图所示：

  

  大致构建图

  沿着这条主线，我们进入parseConfiguration(XNode)方法，接着往下看。

   private void parseConfiguration(XNode root) {
      try {
        //解析下的节点
        //issue #117 read properties first
        //
        propertiesElement(root.evalNode("properties"));
        //
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfs(settings);
        loadCustomLogImpl(settings);
        //别名解析
        // 所谓别名 其实就是把你指定的别名对应的class存储在一个Map当中
        typeAliasesElement(root.evalNode("typeAliases"));
        //插件 
        pluginElement(root.evalNode("plugins"));
        //自定义实例化对象的行为
        objectFactoryElement(root.evalNode("objectFactory"));
        //MateObject   方便反射操作实体类的对象
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631
        //
        environmentsElement(root.evalNode("environments"));
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        // typeHandlers
        typeHandlerElement(root.evalNode("typeHandlers"));
        //主要  指向我们存放SQL的xxxxMapper.xml文件
        mapperElement(root.evalNode("mappers"));
      } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
      }
    }
  

  可以看到这个方法已经在解析下的节点了，例如,,和。

  这里主要使用了分步构建，每个解析不同标签的方法内部都对Configuration对象进行了set或者其它类似的操作，经过这些操作之后，一个Configuration对象就构建完毕了，这里由于代码量比较大，而且大多数构建都是些细节，大概知道怎么用就可以了，就不在文章中说明了，我会挑一个主要的说，当然有兴趣的同学可以自己去pull MyBatis的源码看看。

• Mappers

  上文中提到，mybatis-config.xml文件中我们一定会写一个叫做的标签，这个标签中的节点存放了我们对数据库进行操作的SQL语句，所以这个标签的构建会作为今天分析的重点。

  首先在看源码之前，我们先回忆一下我们在mapper标签内通常会怎样进行配置，通常有如下几种配置方式。

  这是标签的几种配置方式，通过这几种配置方式，可以帮助我们更容易理解mappers的解析。

  private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        //遍历解析mappers下的节点
        for (XNode child : parent.getChildren()) {
        //首先解析package节点
        if ("package".equals(child.getName())) {
          //获取包名
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        } else {
          //如果不存在package节点，那么扫描mapper节点
          //resource/url/mapperClass三个值只能有一个值是有值的
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          //优先级 resource>url>mapperClass
          if (resource != null && url == null && mapperClass == null) {
              //如果mapper节点中的resource不为空
            ErrorContext.instance().resource(resource);
             //那么直接加载resource指向的XXXMapper.xml文件为字节流
            InputStream inputStream = Resources.getResourceAsStream(resource);
            //通过XMLMapperBuilder解析XXXMapper.xml，可以看到这里构建的XMLMapperBuilde还传入了configuration,所以之后肯定是会将mapper封装到configuration对象中去的。
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            //解析
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            //如果url!=null，那么通过url解析
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
              //如果mapperClass!=null，那么通过加载类构造Configuration
            Class mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
        } else {
              //如果都不满足  则直接抛异常  如果配置了两个或三个  直接抛异常
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }
      }
    }
  }
  

  

  通过resource解析

  我们的配置文件中写的是通过resource来加载mapper.xml的，所以会通过XMLMapperBuilder来进行解析，我们可以进去他的parse方法中看一下:

  public void parse() {
      //判断文件是否之前解析过
      if (!configuration.isResourceLoaded(resource)) {
        //解析mapper文件节点（主要）(下面贴了代码)
        configurationElement(parser.evalNode("/mapper"));
        configuration.addLoadedResource(resource);
        //绑定Namespace里面的Class对象
        bindMapperForNamespace();
      }
      //重新解析之前解析不了的节点，先不看，最后填坑。
      parsePendingResultMaps();
      parsePendingCacheRefs();
      parsePendingStatements();
    }
  
  
  //解析mapper文件里面的节点
  // 拿到里面配置的配置项 最终封装成一个MapperedStatemanet
  private void configurationElement(XNode context) {
    try {
        //获取命名空间 namespace，这个很重要，后期mybatis会通过这个动态代理我们的Mapper接口
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
          //如果namespace为空则抛一个异常
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      //解析缓存节点
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
        
      //解析parameterMap（过时）和resultMap  
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      //解析节点 
      //select * from test （可重用的代码段）
      // 
      sqlElement(context.evalNodes("/mapper/sql"));
      //解析增删改查节点   
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
    }
  }
   
  在这个parse()方法中，调用了一个configuationElement代码，用于解析XXXMapper.xml文件中的各种节点，包括、、（已过时）、、、还有增删改查节点，和上面相同的是，我们也挑一个主要的来说，因为解析过程都大同小异。
   
  毋庸置疑的是，我们在XXXMapper.xml中必不可少的就是编写SQL，与数据库交互主要靠的也就是这个，所以着重说说解析增删改查节点的方法——buildStatementFromContext()。
   
  在没贴代码之前，根据这个名字就可以略知一二了，这个方法会根据我们的增删改查节点，来构造一个Statement，而用过原生Jdbc的都知道，Statement就是我们操作数据库的对象。
   
  private void buildStatementFromContext(List list) {
      if (configuration.getDatabaseId() != null) {
        buildStatementFromContext(list, configuration.getDatabaseId());
      }
      //解析xml
      buildStatementFromContext(list, null);
  }
  
  private void buildStatementFromContext(List list, String requiredDatabaseId) {
      for (XNode context : list) {
      final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
      try {
        //解析xml节点
        statementParser.parseStatementNode();
      } catch (IncompleteElementException e) {
        //xml语句有问题时 存储到集合中 等解析完能解析的再重新解析
        configuration.addIncompleteStatement(statementParser);
      }
    }
  }
  
  
  public void parseStatementNode() {
      //获取中的id
      String id = context.getStringAttribute("id");
      //获取databaseId 用于多数据库，这里为null
      String databaseId = context.getStringAttribute("databaseId");
  
      if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
        return;
      }
    //获取节点名  select update delete insert
      String nodeName = context.getNode().getNodeName();
      //根据节点名，得到SQL操作的类型
      SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
      //判断是否是查询
      boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
      //是否刷新缓存 默认:增删改刷新 查询不刷新
      boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
      //是否使用二级缓存 默认值:查询使用 增删改不使用
      boolean useCache = context.getBooleanAttribute("useCache", isSelect);
      //是否需要处理嵌套查询结果 group by
  
      // 三组数据 分成一个嵌套的查询结果
      boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
  
      // Include Fragments before parsing
      XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
      //替换Includes标签为对应的sql标签里面的值
      includeParser.applyIncludes(context.getNode());
  
      //获取parameterType名
      String parameterType = context.getStringAttribute("parameterType");
      //获取parameterType的Class
      Class parameterTypeClass = resolveClass(parameterType);
  
      //解析配置的自定义脚本语言驱动 这里为null
      String lang = context.getStringAttribute("lang");
      LanguageDriver langDriver = getLanguageDriver(lang);
  
      // Parse selectKey after includes and remove them.
      //解析selectKey
      processSelectKeyNodes(id, parameterTypeClass, langDriver);
  
      // Parse the SQL (pre:  and  were parsed and removed)
      //设置主键自增规则
      KeyGenerator keyGenerator;
      String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
      keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
      if (configuration.hasKeyGenerator(keyStatementId)) {
        keyGenerator = configuration.getKeyGenerator(keyStatementId);
      } else {
        keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
            configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
            ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
      }
  /************************************************************************************/
      //解析Sql（重要）  根据sql文本来判断是否需要动态解析 如果没有动态sql语句且 只有#{}的时候 直接静态解析使用?占位 当有 ${} 不解析
      SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
      //获取StatementType，可以理解为Statement和PreparedStatement
      StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
      //没用过
      Integer fetchSize = context.getIntAttribute("fetchSize");
      //超时时间
      Integer timeout = context.getIntAttribute("timeout");
      //已过时
      String parameterMap = context.getStringAttribute("parameterMap");
      //获取返回值类型名
      String resultType = context.getStringAttribute("resultType");
      //获取返回值烈性的Class
      Class resultTypeClass = resolveClass(resultType);
      //获取resultMap的id
      String resultMap = context.getStringAttribute("resultMap");
      //获取结果集类型
      String resultSetType = context.getStringAttribute("resultSetType");
      ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
      if (resultSetTypeEnum == null) {
        resultSetTypeEnum = configuration.getDefaultResultSetType();
      }
      String keyProperty = context.getStringAttribute("keyProperty");
      String keyColumn = context.getStringAttribute("keyColumn");
      String resultSets = context.getStringAttribute("resultSets");
  
      //将刚才获取到的属性，封装成MappedStatement对象（代码贴在下面）
      builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
          fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
          resultSetTypeEnum, flushCache, useCache, resultOrdered,
          keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
    }
  
  //将刚才获取到的属性，封装成MappedStatement对象
    public MappedStatement addMappedStatement(
        String id,
        SqlSource sqlSource,
        StatementType statementType,
        SqlCommandType sqlCommandType,
        Integer fetchSize,
        Integer timeout,
        String parameterMap,
        Class parameterType,
        String resultMap,
        Class resultType,
        ResultSetType resultSetType,
        boolean flushCache,
        boolean useCache,
        boolean resultOrdered,
        KeyGenerator keyGenerator,
        String keyProperty,
        String keyColumn,
        String databaseId,
        LanguageDriver lang,
        String resultSets) {
  
      if (unresolvedCacheRef) {
        throw new IncompleteElementException("Cache-ref not yet resolved");
      }
  
      //id = namespace
      id = applyCurrentNamespace(id, false);
      boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
  
        //通过构造者模式+链式变成，构造一个MappedStatement的构造者
      MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
          .resource(resource)
          .fetchSize(fetchSize)
          .timeout(timeout)
          .statementType(statementType)
          .keyGenerator(keyGenerator)
          .keyProperty(keyProperty)
          .keyColumn(keyColumn)
          .databaseId(databaseId)
          .lang(lang)
          .resultOrdered(resultOrdered)
          .resultSets(resultSets)
          .resultMaps(getStatementResultMaps(resultMap, resultType, id))
          .resultSetType(resultSetType)
          .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
          .useCache(valueOrDefault(useCache, isSelect))
          .cache(currentCache);
  
      ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
      if (statementParameterMap != null) {
        statementBuilder.parameterMap(statementParameterMap);
      }
  
        //通过构造者构造MappedStatement
      MappedStatement statement = statementBuilder.build();
       //将MappedStatement对象封装到Configuration对象中
      configuration.addMappedStatement(statement);
      return statement;
  }
  

  这个代码段虽然很长，但是一句话形容它就是繁琐但不复杂，里面主要也就是对xml的节点进行解析。举个比上面简单的例子吧，假设我们有这样一段配置：

  
      SELECT * FROM test
  
  

  MyBatis需要做的就是，先判断这个节点是用来干什么的，然后再获取这个节点的id、parameterType、resultType等属性，封装成一个MappedStatement对象，由于这个对象很复杂，所以MyBatis使用了构造者模式来构造这个对象，最后当MappedStatement对象构造完成后，将其封装到Configuration对象中。

  代码执行至此，基本就结束了对Configuration对象的构建，MyBatis的第一阶段：构造，也就到这里结束了，现在再来回答我们在文章开头提出的那两个问题：MyBatis需要构造什么对象？以及是否两个配置文件对应着两个对象？，似乎就已经有了答案，这里做一个总结:

  MyBatis需要对配置文件进行解析，最终会解析成一个Configuration对象，但是要说两个配置文件对应了两个对象实际上也没有错：

  1. Configuration对象，保存了mybatis-config.xml的配置信息。
  2. MappedStatement，保存了XXXMapper.xml的配置信息。

但是最终MappedStatement对象会封装到Configuration对象中，合二为一，成为一个单独的对象，也就是Configuration。

最后给大家画一个构建过程的流程图：

MyBatis构建流程图

填坑

• SQL语句在哪解析？

  细心的同学可能已经发现了，上文中只说了去节点中获取一些属性从而构建配置对象，但是最重要的SQL语句并没有提到，这是因为这部分我想要和属性区分开单独说，由于MyBatis支持动态SQL和${}、#{}的多样的SQL，所以这里单独提出来说会比较合适。

  首先可以确认的是，刚才我们走完的那一整个流程中，包含了SQL语句的生成，下面贴代码（这一段代码相当绕，不好读）。

  //解析Sql（重要）  根据sql文本来判断是否需要动态解析 如果没有动态sql语句且 只有#{}的时候 直接静态解析使用?占位 当有 ${} 不解析
      SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
  

  这里就是生成Sql的入口，以单步调试的角度接着往下看。

  /*进入createSqlSource方法*/
  @Override
  public SqlSource createSqlSource(Configuration configuration, XNode script, Class parameterType) {
      //进入这个构造
      XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
      //进入parseScriptNode
      return builder.parseScriptNode();
  }
  /**
  进入这个方法
  */
  public SqlSource parseScriptNode() {
      //#
      //会先解析一遍
      MixedSqlNode rootSqlNode = parseDynamicTags(context);
      SqlSource sqlSource;
      if (isDynamic) {
        //如果是${}会直接不解析，等待执行的时候直接赋值
        sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
      } else {
        //用占位符方式来解析  #{} --> ?
        sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
      }
      return sqlSource;
  }
  protected MixedSqlNode parseDynamicTags(XNode node) {
      List contents = new ArrayList<>();
      //获取select标签下的子标签
      NodeList children = node.getNode().getChildNodes();
      for (int i = 0; i < children.getLength(); i++) {
        XNode child = node.newXNode(children.item(i));
        if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
          //如果是查询
        //获取原生SQL语句 这里是 select * from test where id = #{id}
          String data = child.getStringBody("");
          TextSqlNode textSqlNode = new TextSqlNode(data);
          //检查sql是否是${}
          if (textSqlNode.isDynamic()) {
              //如果是${}那么直接不解析
            contents.add(textSqlNode);
            isDynamic = true;
          } else {
            //如果不是，则直接生成静态SQL
              //#{} -> ?
            contents.add(new StaticTextSqlNode(data));
          }
        } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
          //如果是增删改
          String nodeName = child.getNode().getNodeName();
          NodeHandler handler = nodeHandlerMap.get(nodeName);
          if (handler == null) {
            throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
          }
          handler.handleNode(child, contents);
          isDynamic = true;
        }
      }
      return new MixedSqlNode(contents);
    }
  

  /*从上面的代码段到这一段中间需要经过很多代码，就不一段一段贴了*/
  public SqlSource parse(String originalSql, Class parameterType, Map additionalParameters) {
      ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
      //这里会生成一个GenericTokenParser，传入#{}作为开始和结束，然后调用其parse方法，即可将#{}换为 ?
      GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
      //这里可以解析#{} 将其替换为?
      String sql = parser.parse(originalSql);
      return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
    }
  
  //经过一段复杂的解析过程
  public String parse(String text) {
      if (text == null || text.isEmpty()) {
        return "";
      }
      // search open token
      int start = text.indexOf(openToken);
      if (start == -1) {
        return text;
      }
      char[] src = text.toCharArray();
      int offset = 0;
      final StringBuilder builder = new StringBuilder();
      StringBuilder expression = null;
      //遍历里面所有的#{} select ?  ,#{id1} ${}
      while (start > -1) {
        if (start > 0 && src[start - 1] == '\\') {
          // this open token is escaped. remove the backslash and continue.
          builder.append(src, offset, start - offset - 1).append(openToken);
          offset = start + openToken.length();
        } else {
          // found open token. let's search close token.
          if (expression == null) {
            expression = new StringBuilder();
          } else {
            expression.setLength(0);
          }
          builder.append(src, offset, start - offset);
          offset = start + openToken.length();
          int end = text.indexOf(closeToken, offset);
          while (end > -1) {
            if (end > offset && src[end - 1] == '\\') {
              // this close token is escaped. remove the backslash and continue.
              expression.append(src, offset, end - offset - 1).append(closeToken);
              offset = end + closeToken.length();
              end = text.indexOf(closeToken, offset);
            } else {
              expression.append(src, offset, end - offset);
              break;
            }
          }
          if (end == -1) {
            // close token was not found.
            builder.append(src, start, src.length - start);
            offset = src.length;
          } else {
            //使用占位符 ?
              //注意handler.handleToken()方法，这个方法是核心
            builder.append(handler.handleToken(expression.toString()));
            offset = end + closeToken.length();
          }
        }
        start = text.indexOf(openToken, offset);
      }
      if (offset < src.length) {
        builder.append(src, offset, src.length - offset);
      }
      return builder.toString();
  }
  
  //BindingTokenParser 的handleToken
  //当扫描到${}的时候调用此方法  其实就是不解析 在运行时候在替换成具体的值
  @Override
  public String handleToken(String content) {
    this.isDynamic = true;
    return null;
  }
  //ParameterMappingTokenHandler的handleToken
  //全局扫描#{id} 字符串之后  会把里面所有 #{} 调用handleToken 替换为?
  @Override
  public String handleToken(String content) {
        parameterMappings.add(buildParameterMapping(content));
        return "?";
  }
  

  这段代码相当绕，我们应该站在一个宏观的角度去看待它。所以我直接在这里概括一下：

  首先这里会通过节点获取到我们的SQL语句，假设SQL语句中只有${}，那么直接就什么都不做，在运行的时候直接进行赋值。

  而如果扫描到了#{}字符串之后，会进行替换，将#{}替换为 ?。

  那么他是怎么进行判断的呢？

  这里会生成一个GenericTokenParser，这个对象可以传入一个openToken和closeToken，如果是#{}，那么openToken就是#{，closeToken就是 }，然后通过parse方法中的handler.handleToken()方法进行替换。

  在这之前由于已经进行过SQL是否含有#{}的判断了，所以在这里如果是只有${}，那么handler就是BindingTokenParser的实例化对象，如果存在#{}，那么handler就是ParameterMappingTokenHandler的实例化对象。

  分别进行处理。

  上文中提到的解析不了的节点是什么意思？

  根据上文的代码我们可知，解析Mapper.xml文件中的每个节点是有顺序的。

  那么假设我写了这么几个节点:

  select节点是需要获取resultMap的，但是此时resultMap并没有被解析到，所以解析到这个节点的时候是无法获取到resultMap的信息的。

  我们来看看MyBatis是怎么做的：

  private void buildStatementFromContext(List list, String requiredDatabaseId) {
      for (XNode context : list) {
      final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
      try {
        //解析xml节点
        statementParser.parseStatementNode();
      } catch (IncompleteElementException e) {
        //xml语句有问题时 存储到集合中 等解析完能解析的再重新解析
        configuration.addIncompleteStatement(statementParser);
      }
    }
  }
  

  当解析到某个节点出现问题的时候，会抛一个异常，然后会调用configuration的addIncompleteStatement方法，将这个解析对象先暂存到这个集合中，等到所有的节点都解析完毕之后，在对这个集合内的解析对象继续解析:

  public void parse() {
      //判断文件是否之前解析过
      if (!configuration.isResourceLoaded(resource)) {
        //解析mapper文件
        configurationElement(parser.evalNode("/mapper"));
        configuration.addLoadedResource(resource);
        //绑定Namespace里面的Class对象
        bindMapperForNamespace();
      }
  
      //重新解析之前解析不了的节点
      parsePendingResultMaps();
      parsePendingCacheRefs();
      parsePendingStatements();
  }
  private void parsePendingResultMaps() {
      Collection incompleteResultMaps = configuration.getIncompleteResultMaps();
      synchronized (incompleteResultMaps) {
        Iterator iter = incompleteResultMaps.iterator();
        while (iter.hasNext()) {
          try {
              //添加resultMap
            iter.next().resolve();
            iter.remove();
          } catch (IncompleteElementException e) {
            // ResultMap is still missing a resource...
          }
        }
      }
  }
  public ResultMap resolve() {
      //添加resultMap
      return assistant.addResultMap(this.id, this.type, this.extend, this.discriminator, this.resultMappings, this.autoMapping);
    }
  

  结语

  至此整个MyBatis的查询前构建的过程就基本说完了，简单地总结就是，MyBatis会在执行查询之前，对配置文件进行解析成配置对象：Configuration，以便在后面执行的时候去使用，而存放SQL的xml又会解析成MappedStatement对象，但是最终这个对象也会加入Configuration中，至于Configuration是如何被使用的，以及SQL的执行部分，我会在下一篇说SQL执行的时候分享。

  欢迎大家访问我的个人博客：Object's Blog

  你可能感兴趣的:(MyBatis源码解析(一)——构造篇)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • 情绪觉察日记第37天 露露_e800
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
  • 芦花鞋一四 许叶晗
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 铭刻于星（四十二） 随风至
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说 造命者说
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
  • 2020-01-25 晴岚85
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 想家 爆米花机
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • OC语言多界面传值五大方式 Magnetic_h iosui学习objective-c开发语言
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
  • C语言宏函数 南林yan C语言c语言
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 谢谢你们，爱你们！ 鹿游儿
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
  • C语言如何定义宏函数？ 小九格物 c语言
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • 小丽成长记（四十三） 玲玲54321
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹 黄错错加油
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断 尐尐呅
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
  • 瑶池防线 谜影梦蝶
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
  • 爬山后遗症 璃绛
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • 《策划经理回忆录之二》 路基雅虎
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • JVM StackMapTable 属性的作用及理解 lijingyao8206 jvm字节码Class文件StackMapTable
            在Java 6版本之后JVM引入了栈图(Stack Map Table)概念。为了提高验证过程的效率，在字节码规范中添加了Stack Map Table属性，以下简称栈图，其方法的code属性中存储了局部变量和操作数的类型验证以及字节码的偏移量。也就是一个method需要且仅对应一个Stack Map Table。在Java 7版
  • 回调函数调用方法 百合不是茶 java
    最近在看大神写的代码时,.发现其中使用了很多的回调 ,以前只是在学习的时候经常用到 ,现在写个笔记 记录一下   代码很简单:           MainDemo  :调用方法  得到方法的返回结果        
  • [时间机器]制造时间机器需要一些材料 comsci 制造
          根据我的计算和推测,要完全实现制造一台时间机器,需要某些我们这个世界不存在的物质     和材料...       甚至可以这样说,这种材料和物质,我们在反应堆中也无法获得......      
  • 开口埋怨不如闭口做事 邓集海 邓集海 做人 做事 工作
    “开口埋怨，不如闭口做事。”不是名人名言，而是一个普通父亲对儿子的训导。但是，因为这句训导，这位普通父亲却造就了一个名人儿子。这位普通父亲造就的名人儿子，叫张明正。 　　 　　张明正出身贫寒，读书时成绩差，常挨老师批评。高中毕业，张明正连普通大学的分数线都没上。高考成绩出来后，平时开口怨这怨那的张明正，不从自身找原因，而是不停地埋怨自己家庭条件不好、埋怨父母没有给他创造良好的学习环境。 　　 　　
  • jQuery插件开发全解析，类级别与对象级别开发 IT独行者 jquery开发插件　函数
    jQuery插件的开发包括两种： 一种是类级别的插件开发，即给 jQuery添加新的全局函数，相当于给 jQuery类本身添加方法。 jQuery的全局函数就是属于 jQuery命名空间的函数，另一种是对象级别的插件开发，即给 jQuery对象添加方法。下面就两种函数的开发做详细的说明。   1 、类级别的插件开发 类级别的插件开发最直接的理解就是给jQuer
  • Rome解析Rss 413277409 Rome解析Rss
    import java.net.URL;  import java.util.List;    import org.junit.Test;    import com.sun.syndication.feed.synd.SyndCategory;  import com.sun.syndication.feed.synd.S
  • RSA加密解密 无量 加密解密rsa
    RSA加密解密代码 代码有待整理 package com.tongbanjie.commons.util; import java.security.Key; import java.security.KeyFactory; import java.security.KeyPair; import java.security.KeyPairGenerat
  • linux 软件安装遇到的问题 aichenglong linux遇到的问题ftp
    1 ftp配置中遇到的问题    500 OOPS: cannot change directory   出现该问题的原因:是SELinux安装机制的问题.只要disable SELinux就可以了   修改方法:1 修改/etc/selinux/config 中SELINUX=disabled    2 source /etc
  • 面试心得 alafqq 面试
    最近面试了好几家公司。记录下； 支付宝，面试我的人胖胖的，看着人挺好的；博彦外包的职位，面试失败； 阿里金融，面试官人也挺和善，只不过我让他吐血了。。。 由于印象比较深，记录下； 1，自我介绍 2，说下八种基本类型；（算上string。楼主才答了3种，哈哈，string其实不是基本类型，是引用类型） 3，什么是包装类，包装类的优点； 4，平时看过什么书？NND，什么书都没看过。。照样
  • java的多态性探讨 百合不是茶 java
    java的多态性是指main方法在调用属性的时候类可以对这一属性做出反应的情况 //package 1; class A{ public void test(){ System.out.println("A"); } } class D extends A{ public void test(){ S
  • 网络编程基础篇之JavaScript-学习笔记 bijian1013 JavaScript
    1.documentWrite <html> <head> <script language="JavaScript"> document.write("这是电脑网络学校"); document.close(); </script> </h
  • 探索JUnit4扩展：深入Rule bijian1013 JUnitRule单元测试
            本文将进一步探究Rule的应用，展示如何使用Rule来替代@BeforeClass，@AfterClass，@Before和@After的功能。         在上一篇中提到，可以使用Rule替代现有的大部分Runner扩展，而且也不提倡对Runner中的withBefores()，withAfte
  • [CSS]CSS浮动十五条规则 bit1129 css
    这些浮动规则，主要是参考CSS权威指南关于浮动规则的总结，然后添加一些简单的例子以验证和理解这些规则。   1. 所有的页面元素都可以浮动 2. 一个元素浮动后，会成为块级元素，比如<span>,a, strong等都会变成块级元素 3.一个元素左浮动，会向最近的块级父元素的左上角移动，直到浮动元素的左外边界碰到块级父元素的左内边界；如果这个块级父元素已经有浮动元素停靠了
  • 【Kafka六】Kafka Producer和Consumer多Broker、多Partition场景 bit1129 partition
    0.Kafka服务器配置 3个broker 1个topic，6个partition，副本因子是2 2个consumer，每个consumer三个线程并发读取   1. Producer package kafka.examples.multibrokers.producers; import java.util.Properties; import java.util.
  • zabbix_agentd.conf配置文件详解 ronin47 zabbix 配置文件
    Aliaskey的别名，例如 Alias=ttlsa.userid:vfs.file.regexp[/etc/passwd,^ttlsa:.:([0-9]+),,,,\1]， 或者ttlsa的用户ID。你可以使用key：vfs.file.regexp[/etc/passwd,^ttlsa:.: ([0-9]+),,,,\1]，也可以使用ttlsa.userid。备注: 别名不能重复，但是可以有多个
  • java--19.用矩阵求Fibonacci数列的第N项 bylijinnan fibonacci
    参考了网上的思路，写了个Java版的： public class Fibonacci { final static int[] A={1,1,1,0}; public static void main(String[] args) { int n=7; for(int i=0;i<=n;i++){ int f=fibonac
  • Netty源码学习-LengthFieldBasedFrameDecoder bylijinnan javanetty
    先看看LengthFieldBasedFrameDecoder的官方API http://docs.jboss.org/netty/3.1/api/org/jboss/netty/handler/codec/frame/LengthFieldBasedFrameDecoder.html API举例说明了LengthFieldBasedFrameDecoder的解析机制，如下： 实
  • AES加密解密 chicony 加密解密
    AES加解密算法，使用Base64做转码以及辅助加密： package com.wintv.common; import javax.crypto.Cipher; import javax.crypto.spec.IvParameterSpec; import javax.crypto.spec.SecretKeySpec; import sun.misc.BASE64Decod
  • 文件编码格式转换 ctrain 编码格式
    package com.test; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream;
  • mysql 在linux客户端插入数据中文乱码 daizj mysql中文乱码
    1、查看系统客户端，数据库，连接层的编码  查看方法： http://daizj.iteye.com/blog/2174993 进入mysql，通过如下命令查看数据库编码方式： mysql>  show variables like 'character_set_%'; +--------------------------+------
  • 好代码是廉价的代码 dcj3sjt126com 程序员读书
      长久以来我一直主张：好代码是廉价的代码。 当我跟做开发的同事说出这话时，他们的第一反应是一种惊愕，然后是将近一个星期的嘲笑，把它当作一个笑话来讲。 当他们走近看我的表情、知道我是认真的时，才收敛一点。 当最初的惊愕消退后，他们会用一些这样的话来反驳： “好代码不廉价，好代码是采用经过数十年计算机科学研究和积累得出的最佳实践设计模式和方法论建立起来的精心制作的程序代码。” 我只
  • Android网络请求库——android-async-http dcj3sjt126com android
    在iOS开发中有大名鼎鼎的ASIHttpRequest库，用来处理网络请求操作，今天要介绍的是一个在Android上同样强大的网络请求库android-async-http，目前非常火的应用Instagram和Pinterest的Android版就是用的这个网络请求库。这个网络请求库是基于Apache HttpClient库之上的一个异步网络请求处理库，网络处理均基于Android的非UI线程，通
  • ORACLE 复习笔记之SQL语句的优化 eksliang SQL优化Oracle sql语句优化SQL语句的优化
    转载请出自出处：http://eksliang.iteye.com/blog/2097999   SQL语句的优化总结如下   sql语句的优化可以按照如下六个步骤进行： 合理使用索引 避免或者简化排序 消除对大表的扫描 避免复杂的通配符匹配 调整子查询的性能 EXISTS和IN运算符 下面我就按照上面这六个步骤分别进行总结：
  • 浅析：Android 嵌套滑动机制（NestedScrolling） gg163 android移动开发滑动机制嵌套
    谷歌在发布安卓 Lollipop版本之后，为了更好的用户体验，Google为Android的滑动机制提供了NestedScrolling特性 NestedScrolling的特性可以体现在哪里呢？<!--[if !supportLineBreakNewLine]--><!--[endif]--> 比如你使用了Toolbar，下面一个ScrollView，向上滚
  • 使用hovertree菜单作为后台导航 hvt JavaScriptjquery.nethovertreeasp.net
      hovertree是一个jquery菜单插件，官方网址：http://keleyi.com/jq/hovertree/ ，可以登录该网址体验效果。 0.1.3版本：http://keleyi.com/jq/hovertree/demo/demo.0.1.3.htm hovertree插件包含文件： http://keleyi.com/jq/hovertree/css
  • SVG 教程 （二）矩形 天梯梦 svg
    SVG <rect> SVG Shapes SVG有一些预定义的形状元素，可被开发者使用和操作： 矩形 <rect> 圆形 <circle> 椭圆 <ellipse> 线 <line> 折线 <polyline> 多边形 <polygon> 路径 <path>
  • 一个简单的队列 luyulong java数据结构队列
    public class MyQueue { private long[] arr; private int front; private int end; // 有效数据的大小 private int elements; public MyQueue() { arr = new long[10]; elements = 0; front
  • 基础数据结构和算法九：Binary Search Tree sunwinner Algorithm
      A binary search tree (BST) is a binary tree where each node has a Comparable key (and an associated value) and satisfies the restriction that the key in any node is larger than the keys in all
  • 项目出现的一些问题和体会 Steven-Walker DAOWebservlet
         第一篇博客不知道要写点什么，就先来点近阶段的感悟吧。     这几天学了servlet和数据库等知识，就参照老方的视频写了一个简单的增删改查的，完成了最简单的一些功能，使用了三层架构。 dao层完成的是对数据库具体的功能实现，service层调用了dao层的实现方法，具体对servlet提供支持。  &
  • 高手问答：Java老A带你全面提升Java单兵作战能力！ ITeye管理员 java
    本期特邀《Java特种兵》作者：谢宇，CSDN论坛ID: xieyuooo 针对JAVA问题给予大家解答，欢迎网友积极提问，与专家一起讨论! 作者简介： 淘宝网资深Java工程师，CSDN超人气博主，人称“胖哥”。 CSDN博客地址： http://blog.csdn.net/xieyuooo 作者在进入大学前是一个不折不扣的计算机白痴，曾经被人笑话过不懂鼠标是什么，

  按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

  首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

  版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.