Nicksxs's Blog

What hurts more, the pain of hard work or the pain of regret?

发表于 分类于 阅读次数： Disqus：

添加节点

添加节点非常简单，比如 app store 或者官网可以下载 mac 的安装包，

安装包直接下载可以在这里，下载安装完后还需要做一些处理，才能让 Tailscale 使用 Headscale 作为控制服务器。当然，Headscale 已经给我们提供了详细的操作步骤，你只需要在浏览器中打开 URL：http://<HEADSCALE_PUB_IP>:<HEADSCALE_PUB_PORT>/apple，记得端口替换成自己的，就会看到这样的说明页

image

然后对于像我这样自己下载的客户端安装包，也就是standalone client，就可以用下面的命令

defaults write io.tailscale.ipn.macsys ControlURL http://<HEADSCALE_PUB_IP>:<HEADSCALE_PUB_PORT> 类似于 Windows 客户端需要写入注册表，就是把控制端的地址改成了我们自己搭建的 headscale 的，设置完以后就打开 tailscale 客户端右键点击 login，就会弹出一个浏览器地址

image

按照这个里面的命令去 headscale 的机器上执行，注意要替换 namespace，对于最新的 headscale 已经把 namespace 废弃改成 user 了，这点要注意了，其他客户端也同理，现在还有个好消息，安卓和 iOS 客户端也已经都可以用了，后面可以在介绍下局域网怎么部分打通和自建 derper。

发表于 更新于 分类于 阅读次数： Disqus：

最近折腾了个自建的 nas，为了使用 jellyfin 这样的影视应用需要对视频进行刮削，对于电视剧来说还是有些不一样的，
比如我要刮削这部经典电视剧纪晓岚

像这样的命名方式在 tmm 中是无法识别的，或者就得一集一集进行制定刮削，

所以第一步需要进行改名
比如这是第一季的，那就是 S01，然后按集数 E01，第一季第一集的文件名就是 S01E01.mkv
然后右键点击搜索刮削，默认会以文件夹名进行搜索，是在 tmdb 数据库进行搜索

这样除非文件夹名很符合要求，一般都刮削不出来，所以需要有两种刮削方式，一种就是比较标准的命名，这样的名字可以手动先去豆瓣或者 tmdb 搜索，另一个种也可以在豆瓣找到 imdb 的 id 进行搜索

但有时候也会搜不到，比如这个纪晓岚就是搜不到，但是之前的一些韩剧什么的很多都能搜到

这个其实是最基本的刮削，但是这样刮削了需要在 jellyfin 那取消元数据下载
，这样就不会被覆盖

发表于 分类于 ， 阅读次数： Disqus：

这个可能是个很简单的点，不过之前碰到了就记录下，我们常规的应用都是使用统一的请求响应转换器去处理请求和响应返回，但是对于有文件上传或者返回的是文件的情况，一般都是不使用统一的处理，但是在响应返回的时候可能会存在这样的情况，如果文件正常被处理那就返回文件，如果处理异常需要给前端返回 json类型的响应，里面能够取到响应码错误描述等

比如在请求中参数就使用 httpRequest(HttpServletRequest request, HttpServletResponse response)
然后在返回的时候就使用 response.getOutputStream().write(result)，而如果是要返回 json 形式的话就可以像这个文章说明的
链接

1
2
3
4
5
6
7
8
Employee employee = new Employee(1, "Karan", "IT", 5000);
String employeeJsonString = this.gson.toJson(employee);

PrintWriter out = response.getWriter();
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
out.print(employeeJsonString);
out.flush();

一开始我也是这么一搜就用了，后来发现返回的一直是乱码，仔细看了下发现了个问题，就是这个 response 设置 contentType 是在getWriter之后的，这样自然就不会起作用了，所以要在设置 setContentType 和 setCharacterEncoding 之后再 getWriter，之后就可以正常返回了。

发表于 分类于 阅读次数： Disqus：

最近在搞 nas 的时候又翻了个很大的错误，因为前面说了正在用的技嘉的 z370m, 这个主板是跟 cpu 一起买的，如果是只是用在 Windows 环境，没什么扩展要求，或者只用 6 个sata盘位，用一个 ssd 做系统盘，是挺不错的，但是如果是像我这样的要搞盘位比较多的nas，发现有一系列的不足点，
1、 前面有讲过，网卡问题，用的是 RTL 瑞昱的网卡，目前知道的最高能支持的 exsi 的版本是 6.7，再高的版本就不支持了，不过其实真的想用的话，6.7 版本也是可以用的，只是我当时是打包的 8.0 的系统，个人也不太喜欢用比较低版本的，所以算是一个不足点
2、 第二点是m.2插槽，只有一个m.2也是很难理解的，一个做系统盘，另一个可以作为简单的数组存储，或者作为群晖的下载缓存，如果只有一个的话特别是现在这个 ssd 的价格这么低了，加一个还是很香的，这个问题跟后面也是有点关系的
3、 PCIE 的插槽，这个主板只支持两个 PCIE 3.0 x1 的，它能支持 1Gbps 的传输速度，后面我买了个 PCIE 3.0 x1 转 m.2 的转接卡，这样其实真的是把速度拖慢了很多，还有一个 PCIE 3.0 X16 的，这是用来装显卡的，只用来扩展做个m.2或者 sata 又感觉很浪费，而且说不定未来会装个显卡
4、 风扇口的问题，风扇接口其实原来一直没概念，我在这次装 nas 之前其实自己没有完整装个台式机过，之前买的目前在使用的主力机两个风扇在换了的时候才知道是用的大 4pin 接口串接的，其中一个有 pwm 的接口也没用，这样就没办法用主板自带调速软件来进行自动或者手动调速，有时候比如晚上不关机，放在房间里风扇声很大还是挺吵的，这个主板只有两个风扇接口，一个是 cpu 的，一个是系统风扇，其实就只有一个可以用了
主要是以上几个点，所以我一直在关注二手主板，之前买了个华硕的 z370 tuf gaming，没想到点不亮，也不知道什么原因，还害我吓得以为 cpu 被我弄坏了，后面慢慢在网上看着发现有一块微星的 z390 TOMAHAWK战斧导弹，各方面接口都很不错，而且还有个千兆网口，在闲鱼蹲了很久终于在前不久蹲到了，买回来赶紧看看能不能点亮，结果一把点亮，还是用的螺丝刀开机的，就心里暗爽感觉捡到了宝，但是装进我的半岛铁盒 F10 机箱就发现跪了，出现的这个问题原来在网上哪里看到过，一直没注意，就是 sata 接口的方向，因为一个是 matx 的板，装进去即使 sata 接口的方向是跟主板平行的也留着足够的空间，但是 atx 板装上之后，大概只有 2 厘米左右的空间并且是两个叠着的端口，一个可能要能硬拗一下，但是两个我试了下，只能识别出一个，这个真让我翻了个大车，而且其实我换这个主板其实还有个大问题，就是我是在 Windows 下的vmware workstation 虚拟机里通过sata 直通，但是这个是认硬盘接口的，也就是顺序是有影响的，换了主板发现也不能支持，后面可能真的想用的话还得重新搞黑裙，要把数据备份出来，幸好换回原来的主板还能用，所以硬件也不能只看性能和接口丰富度，要看适配的其他硬件的合适度以及原先已经有的软件系统

发表于 分类于 ， 阅读次数： Disqus：

在 org.apache.ibatis.builder.xml.XMLConfigBuilder#parseConfiguration 中进行配置解析，其中这一行就是解析 mappers

1
mapperElement(root.evalNode("mappers"));

具体的代码会执行到这

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      if ("package".equals(child.getName())) {
        // 这里解析的不是 package
        String mapperPackage = child.getStringAttribute("name");
        configuration.addMappers(mapperPackage);
      } else {
        // 根据 resource 和 url 还有 mapperClass 判断
        String resource = child.getStringAttribute("resource");
        String url = child.getStringAttribute("url");
        String mapperClass = child.getStringAttribute("class");
        // resource 不为空其他为空的情况，就开始将 resource 读成输入流
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          try(InputStream inputStream = Resources.getResourceAsStream(resource)) {
            // 初始化 XMLMapperBuilder 来解析 mapper
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          }

然后再是 parse 过程

1
2
3
4
5
6
7
8
9
10
11
12
public void parse() {
  if (!configuration.isResourceLoaded(resource)) {
    // 解析 mapper 节点，也就是下图中的mapper
    configurationElement(parser.evalNode("/mapper"));
    configuration.addLoadedResource(resource);
    bindMapperForNamespace();
  }

  parsePendingResultMaps();
  parsePendingCacheRefs();
  parsePendingStatements();
}

image

继续往下走

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.isEmpty()) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      // 处理cache 和 cache 应用
      cacheRefElement(context.evalNode("cache-ref"));
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      sqlElement(context.evalNodes("/mapper/sql"));
      // 因为我们是个 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);
    }
  }

然后是

1
2
3
4
5
6
7
private void buildStatementFromContext(List<XNode> list) {
  if (configuration.getDatabaseId() != null) {
    buildStatementFromContext(list, configuration.getDatabaseId());
  }
  // 然后没有 databaseId 就走到这
  buildStatementFromContext(list, null);
}

继续

1
2
3
4
5
6
7
8
9
10
11
12
private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
  for (XNode context : list) {
    // 创建语句解析器
    final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    try {
      // 解析节点
      statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
      configuration.addIncompleteStatement(statementParser);
    }
  }
}

这个代码比较长，做下简略，只保留相关代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public void parseStatementNode() {
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");

    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }

    String nodeName = context.getNode().getNodeName();
    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);
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);


    // 简略前后代码，主要看这里，创建 sqlSource

    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

然后根据 LanguageDriver，我们这用的 XMLLanguageDriver，先是初始化

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
  @Override
  public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
    XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
    return builder.parseScriptNode();
  }
// 初始化有一些逻辑
  public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) {
    super(configuration);
    this.context = context;
    this.parameterType = parameterType;
    // 特别是这，我这次特意在 mapper 中加了 foreach，就是为了说下这一块的解析
    initNodeHandlerMap();
  }
// 设置各种类型的处理器
  private void initNodeHandlerMap() {
    nodeHandlerMap.put("trim", new TrimHandler());
    nodeHandlerMap.put("where", new WhereHandler());
    nodeHandlerMap.put("set", new SetHandler());
    nodeHandlerMap.put("foreach", new ForEachHandler());
    nodeHandlerMap.put("if", new IfHandler());
    nodeHandlerMap.put("choose", new ChooseHandler());
    nodeHandlerMap.put("when", new IfHandler());
    nodeHandlerMap.put("otherwise", new OtherwiseHandler());
    nodeHandlerMap.put("bind", new BindHandler());
  }

初始化解析器以后就开始解析了

1
2
3
4
5
6
7
8
9
10
11
public SqlSource parseScriptNode() {
  // 先是解析 parseDynamicTags
  MixedSqlNode rootSqlNode = parseDynamicTags(context);
  SqlSource sqlSource;
  if (isDynamic) {
    sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
  } else {
    sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
  }
  return sqlSource;
}

但是这里可能做的事情比较多

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
29
30
31
32
33
protected MixedSqlNode parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<>();
    // 获取子节点，这里可以把我 xml 中的 SELECT 语句分成三部分，第一部分是 select 到 in，然后是 foreach 部分，最后是\n结束符
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
      XNode child = node.newXNode(children.item(i));
      // 第一个节点是个纯 text 节点就会走到这
      if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
        String data = child.getStringBody("");
        TextSqlNode textSqlNode = new TextSqlNode(data);
        if (textSqlNode.isDynamic()) {
          contents.add(textSqlNode);
          isDynamic = true;
        } else {
          // 在 content 中添加这个 node
          contents.add(new StaticTextSqlNode(data));
        }
      } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
        // 第二个节点是个带 foreach 的，是个内部元素节点
        String nodeName = child.getNode().getNodeName();
        // 通过 nodeName 获取处理器
        NodeHandler handler = nodeHandlerMap.get(nodeName);
        if (handler == null) {
          throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
        }
        // 调用处理器来处理
        handler.handleNode(child, contents);
        isDynamic = true;
      }
    }
    // 然后返回这个混合 sql 节点
    return new MixedSqlNode(contents);
  }

再看下 handleNode 的逻辑

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      // 又会套娃执行这里的 parseDynamicTags
      MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
      String collection = nodeToHandle.getStringAttribute("collection");
      Boolean nullable = nodeToHandle.getBooleanAttribute("nullable");
      String item = nodeToHandle.getStringAttribute("item");
      String index = nodeToHandle.getStringAttribute("index");
      String open = nodeToHandle.getStringAttribute("open");
      String close = nodeToHandle.getStringAttribute("close");
      String separator = nodeToHandle.getStringAttribute("separator");
      ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, nullable, index, item, open, close, separator);
      targetContents.add(forEachSqlNode);
    }
// 这里走的逻辑不一样了
protected MixedSqlNode parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<>();
    // 这里是 foreach 内部的，所以是个 text_node
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
      XNode child = node.newXNode(children.item(i));
      // 第一个节点是个纯 text 节点就会走到这
      if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
        String data = child.getStringBody("");
        TextSqlNode textSqlNode = new TextSqlNode(data);
        // 判断是否动态是根据代码里是否有 ${}
        if (textSqlNode.isDynamic()) {
          contents.add(textSqlNode);
          isDynamic = true;
        } else {
          // 所以还是会走到这
          // 在 content 中添加这个 node
          contents.add(new StaticTextSqlNode(data));
        }
// 最后继续包装成 MixedSqlNode
// 再回到这里
    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
      // 处理 foreach 内部的各个变量
      String collection = nodeToHandle.getStringAttribute("collection");
      Boolean nullable = nodeToHandle.getBooleanAttribute("nullable");
      String item = nodeToHandle.getStringAttribute("item");
      String index = nodeToHandle.getStringAttribute("index");
      String open = nodeToHandle.getStringAttribute("open");
      String close = nodeToHandle.getStringAttribute("close");
      String separator = nodeToHandle.getStringAttribute("separator");
      ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, nullable, index, item, open, close, separator);
      targetContents.add(forEachSqlNode);
    }

再回过来

1
2
3
4
5
6
7
8
9
10
11
12
public SqlSource parseScriptNode() {
  MixedSqlNode rootSqlNode = parseDynamicTags(context);
  SqlSource sqlSource;
  // 因为在 foreach 节点处理时直接是把 isDynamic 置成了 true
  if (isDynamic) {
    // 所以是个 DynamicSqlSource
    sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
  } else {
    sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
  }
  return sqlSource;
}

这里就做完了预处理工作，真正在执行的执行的时候还需要进一步解析

因为前面讲过很多了，所以直接跳到这里

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
  @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);
    if (list.size() == 1) {
      return list.get(0);
    } else if (list.size() > 1) {
      throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
    } else {
      return null;
    }
  }

  @Override
  public <E> List<E> selectList(String statement, Object parameter) {
    return this.selectList(statement, parameter, RowBounds.DEFAULT);
  }
  @Override
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
    return selectList(statement, parameter, rowBounds, Executor.NO_RESULT_HANDLER);
  }
  private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    try {
      // 前面也讲过这个，
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }
  // 包括这里，是调用的org.apache.ibatis.executor.CachingExecutor#query(org.apache.ibatis.mapping.MappedStatement, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler)
  @Override
  public <E> List<E> 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);
  }
// 然后是获取 BoundSql
  public BoundSql getBoundSql(Object parameterObject) {
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings == null || parameterMappings.isEmpty()) {
      boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }

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

    return boundSql;
  }
// 因为前面讲了是生成的 DynamicSqlSource，所以也是调用这个的 getBoundSql
  @Override
  public BoundSql getBoundSql(Object parameterObject) {
    DynamicContext context = new DynamicContext(configuration, parameterObject);
    // 重点关注着
    rootSqlNode.apply(context);
    SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
    Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
    SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    context.getBindings().forEach(boundSql::setAdditionalParameter);
    return boundSql;
  }
// 继续是这个 DynamicSqlNode 的 apply
  public boolean apply(DynamicContext context) {
    contents.forEach(node -> node.apply(context));
    return true;
  }
// 看下面的图

image

我们重点看 foreach 的逻辑

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
@Override
  public boolean apply(DynamicContext context) {
    Map<String, Object> bindings = context.getBindings();
    final Iterable<?> iterable = evaluator.evaluateIterable(collectionExpression, bindings,
      Optional.ofNullable(nullable).orElseGet(configuration::isNullableOnForEach));
    if (iterable == null || !iterable.iterator().hasNext()) {
      return true;
    }
    boolean first = true;
    // 开始符号
    applyOpen(context);
    int i = 0;
    for (Object o : iterable) {
      DynamicContext oldContext = context;
      if (first || separator == null) {
        context = new PrefixedContext(context, "");
      } else {
        context = new PrefixedContext(context, separator);
      }
      int uniqueNumber = context.getUniqueNumber();
      // Issue #709
      if (o instanceof Map.Entry) {
        @SuppressWarnings("unchecked")
        Map.Entry<Object, Object> mapEntry = (Map.Entry<Object, Object>) o;
        applyIndex(context, mapEntry.getKey(), uniqueNumber);
        applyItem(context, mapEntry.getValue(), uniqueNumber);
      } else {
        applyIndex(context, i, uniqueNumber);
        applyItem(context, o, uniqueNumber);
      }
      // 转换变量名，变成这种形式 select * from student where id in
      //   (  
      //  #{__frch_id_0}
      //   )
      contents.apply(new FilteredDynamicContext(configuration, context, index, item, uniqueNumber));
      if (first) {
        first = !((PrefixedContext) context).isPrefixApplied();
      }
      context = oldContext;
      i++;
    }
    applyClose(context);
    context.getBindings().remove(item);
    context.getBindings().remove(index);
    return true;
  }
// 回到外层就会调用 parse 方法， 把#{} 这段替换成 ?
public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
    ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
    GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
    String sql;
    if (configuration.isShrinkWhitespacesInSql()) {
      sql = parser.parse(removeExtraWhitespaces(originalSql));
    } else {
      sql = parser.parse(originalSql);
    }
    return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
  }

image

可以看到这里，然后再进行替换

image

真实的从 ? 替换成具体的变量值，是在这里
org.apache.ibatis.executor.SimpleExecutor#doQuery
调用了

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
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;
  }
  @Override
  public void parameterize(Statement statement) throws SQLException {
    parameterHandler.setParameters((PreparedStatement) statement);
  }
    @Override
  public void setParameters(PreparedStatement ps) {
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
      for (int i = 0; i < parameterMappings.size(); i++) {
        ParameterMapping parameterMapping = parameterMappings.get(i);
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          Object value;
          String propertyName = parameterMapping.getProperty();
          if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          } else {
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          JdbcType jdbcType = parameterMapping.getJdbcType();
          if (value == null && jdbcType == null) {
            jdbcType = configuration.getJdbcTypeForNull();
          }
          try {
            // --------------------------> 
            // 替换变量
            typeHandler.setParameter(ps, i + 1, value, jdbcType);
          } catch (TypeException | SQLException e) {
            throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
          }
        }
      }
    }
  }
0%