Nicksxs's Blog

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

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

前一篇讲了mybatis的初始化使用，如果我第一次看到这个使用入门文档，比较会产生疑惑的是配置了mapper，怎么就能通过selectOne跟语句id就能执行sql了，那么第一个问题，就是mapper是怎么被解析的，存在哪里，怎么被拿出来的

添加解析mapper

1
2
3
4
org.apache.ibatis.session.SqlSessionFactoryBuilder#build(java.io.InputStream)
public SqlSessionFactory build(InputStream inputStream) {
  return build(inputStream, null, null);
}

通过读取mybatis-config.xml来构建SqlSessionFactory，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
  try {
    // 创建下xml的解析器
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    // 进行解析，后再构建
    return build(parser.parse());
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
  } finally {
    ErrorContext.instance().reset();
    try {
       if (inputStream != null) {
         inputStream.close();
       }
    } catch (IOException e) {
      // Intentionally ignore. Prefer previous error.
    }
  }

创建XMLConfigBuilder

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
    // --------> 创建 XPathParser
  this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
}

public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver) {
    commonConstructor(validation, variables, entityResolver);
    this.document = createDocument(new InputSource(inputStream));
  }

private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
  super(new Configuration());
  ErrorContext.instance().resource("SQL Mapper Configuration");
  this.configuration.setVariables(props);
  this.parsed = false;
  this.environment = environment;
  this.parser = parser;
}

这里主要是创建了Builder包含了Parser
然后调用parse方法

1
2
3
4
5
6
7
8
9
10
public Configuration parse() {
  if (parsed) {
    throw new BuilderException("Each XMLConfigBuilder can only be used once.");
  }
  // 标记下是否已解析，但是这里是否有线程安全问题
  parsed = true;
  // --------> 解析配置
  parseConfiguration(parser.evalNode("/configuration"));
  return configuration;
}

实际的解析区分了各类标签

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
private void parseConfiguration(XNode root) {
  try {
    // issue #117 read properties first
    // 解析properties，这个不是spring自带的，需要额外配置，并且在config文件里应该放在最前
    propertiesElement(root.evalNode("properties"));
    Properties settings = settingsAsProperties(root.evalNode("settings"));
    loadCustomVfs(settings);
    loadCustomLogImpl(settings);
    typeAliasesElement(root.evalNode("typeAliases"));
    pluginElement(root.evalNode("plugins"));
    objectFactoryElement(root.evalNode("objectFactory"));
    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"));
    typeHandlerElement(root.evalNode("typeHandlers"));
    // ----------> 我们需要关注的是mapper的处理
    mapperElement(root.evalNode("mappers"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  }
}

然后就是调用到mapperElement方法了

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
private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      if ("package".equals(child.getName())) {
        String mapperPackage = child.getStringAttribute("name");
        configuration.addMappers(mapperPackage);
      } else {
        String resource = child.getStringAttribute("resource");
        String url = child.getStringAttribute("url");
        String mapperClass = child.getStringAttribute("class");
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          try(InputStream inputStream = Resources.getResourceAsStream(resource)) {
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            // --------> 我们这没有指定package，所以是走到这
            mapperParser.parse();
          }
        } else if (resource == null && url != null && mapperClass == null) {
          ErrorContext.instance().resource(url);
          try(InputStream inputStream = Resources.getUrlAsStream(url)){
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          }
        } else if (resource == null && url == null && mapperClass != null) {
          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.");
        }
      }
    }
  }
}

核心就在这个parse()方法

1
2
3
4
5
6
7
8
9
10
11
12
public void parse() {
  if (!configuration.isResourceLoaded(resource)) {
    // -------> 然后就是走到这里,配置xml的mapper节点的内容
    configurationElement(parser.evalNode("/mapper"));
    configuration.addLoadedResource(resource);
    bindMapperForNamespace();
  }

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

具体的处理逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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);
    cacheRefElement(context.evalNode("cache-ref"));
    cacheElement(context.evalNode("cache"));
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    sqlElement(context.evalNodes("/mapper/sql"));
    // ------->  走到这，从上下文构建statement
    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);
  }
}

具体代码在这，从上下文构建statement，只不过区分了下databaseId

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

判断下databaseId

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

接下来就是真正处理的xml语句内容的，各个节点的信息内容

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

  // Include Fragments before parsing
  XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
  includeParser.applyIncludes(context.getNode());

  String parameterType = context.getStringAttribute("parameterType");
  Class<?> parameterTypeClass = resolveClass(parameterType);

  String lang = context.getStringAttribute("lang");
  LanguageDriver langDriver = getLanguageDriver(lang);

  // Parse selectKey after includes and remove them.
  processSelectKeyNodes(id, parameterTypeClass, langDriver);

  // Parse the SQL (pre: <selectKey> and <include> 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;
  }

  // 语句的主要参数解析
  SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
  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<?> resultTypeClass = resolveClass(resultType);
  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");

  // --------> 添加映射的statement
  builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
      fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
      resultSetTypeEnum, flushCache, useCache, resultOrdered,
      keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}

添加的逻辑具体可以看下

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
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 = applyCurrentNamespace(id, false);
  boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

  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 statement = statementBuilder.build();
  // ------>  正好是这里在configuration中添加了映射好的statement
  configuration.addMappedStatement(statement);
  return statement;
}

而里面就是往map里添加

1
2
3
public void addMappedStatement(MappedStatement ms) {
  mappedStatements.put(ms.getId(), ms);
}

获取mapper

1
StudentDO studentDO = session.selectOne("com.nicksxs.mybatisdemo.StudentMapper.selectStudent", 1);

就是调用了 org.apache.ibatis.session.defaults.DefaultSqlSession#selectOne(java.lang.String, java.lang.Object)

1
2
3
4
5
6
7
8
9
10
11
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;
  }
}

调用实际的实现方法

1
2
3
public <E> List<E> selectList(String statement, Object parameter) {
  return this.selectList(statement, parameter, RowBounds.DEFAULT);
}

这里还有一层

1
2
3
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
  return selectList(statement, parameter, rowBounds, Executor.NO_RESULT_HANDLER);
}

根本的就是从configuration里获取了mappedStatement

1
2
3
4
5
6
7
8
9
10
11
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();
  }
}

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

mybatis是我们比较常用的orm框架，下面是官网的介绍

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

mybatis一大特点，或者说比较为人熟知的应该就是比 hibernate 是更轻量化，为国人所爱好的orm框架，对于hibernate目前还没有深入的拆解过，后续可以也写一下，在使用体验上觉得是个比较精巧的框架，看代码也比较容易，所以就想写个系列，第一篇先是介绍下使用
根据官网的文档上我们先来尝试一下简单使用
首先我们有个简单的配置，这个文件是mybatis-config.xml

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
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 需要加入的properties-->
    <properties resource="application-development.properties"/>
    <!-- 指出使用哪个环境，默认是development-->
    <environments default="development">
        <environment id="development">
        <!-- 指定事务管理器类型-->
            <transactionManager type="JDBC"/>
            <!-- 指定数据源类型-->
            <dataSource type="POOLED">
                <!-- 下面就是具体的参数占位了-->
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <!-- 指定mapper xml的位置或文件-->
        <mapper resource="mapper/StudentMapper.xml"/>
    </mappers>
</configuration>

在代码里创建mybatis里重要入口

1
2
3
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

然后我们上面的StudentMapper.xml

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.nicksxs.mybatisdemo.StudentMapper">
    <select id="selectStudent" resultType="com.nicksxs.mybatisdemo.StudentDO">
        select * from student where id = #{id}
    </select>
</mapper>

那么我们就要使用这个mapper，

1
2
3
4
5
6
7
8
9
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
try (SqlSession session = sqlSessionFactory.openSession()) {
    StudentDO studentDO = session.selectOne("com.nicksxs.mybatisdemo.StudentMapper.selectStudent", 1);
    System.out.println("id is " + studentDO.getId() + " name is " +studentDO.getName());
} catch (Exception e) {
    e.printStackTrace();
}

sqlSessionFactory是sqlSession的工厂，我们可以通过sqlSessionFactory来创建sqlSession，而SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。可以看到mapper.xml中有定义mapper的namespace，就可以通过session.selectOne()传入namespace+id来调用这个方法
但是这样调用比较不合理的点，或者说按后面mybatis优化之后我们可以指定mapper接口

1
2
3
4
public interface StudentMapper {

    public StudentDO selectStudent(Long id);
}

就可以可以通过mapper接口获取方法，这样就不用涉及到未知的变量转换等异常

1
2
3
4
5
6
7
try (SqlSession session = sqlSessionFactory.openSession()) {
    StudentMapper mapper = session.getMapper(StudentMapper.class);
    StudentDO studentDO = mapper.selectStudent(1L);
    System.out.println("id is " + studentDO.getId() + " name is " +studentDO.getName());
} catch (Exception e) {
    e.printStackTrace();
}

这一篇咱们先介绍下简单的使用，后面可以先介绍下这些的原理。

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

powershell创建数组也很方便
可以这样

1
$nums=2,0,1,2

顺便可以用下我们上次学到的gettype()

如果是想创建连续数字的数组还可以用这个方便的方法

1
$nums=1..5


而且数组还可以存放各种类型的数据

1
$array=1,"哈哈",([System.Guid]::NewGuid()),(get-date)


还有判断类型可以用-is

创建一个空数组

1
$array=@()


数组添加元素

1
$array+="a"


数组删除元素

1
2
$a=1..4
$a=$a[0..1]+$a[3]

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

powershell变量

变量命名类似于php

1
2
3
4
PS C:\Users\Nicks> $a=1
PS C:\Users\Nicks> $b=2
PS C:\Users\Nicks> $a*$b
2

有一个比较好用的是变量交换
一般的语言做两个变量交换一般需要一个临时变量

1
2
3
$tmp=$a
$a=$b
$b=$tmp

而在powershell中可以这样

1
2
3
4
5
6
$a,$b=$b,$a
PS C:\Users\Nicks> $a,$b=$b,$a
PS C:\Users\Nicks> $a
2
PS C:\Users\Nicks> $b
1

还可以通过这个

1
2
3
4
5
6
7
8
9
10
PS C:\Users\Nicks> ls variable:

Name                           Value
----                           -----
$                              $b
?                              True
^                              $b
a                              2
args                           {}
b                              1

查看现存的变量
当然一般脚本都是动态类型的，
可以通过
gettype方法

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

这是一次开车过程中结合网上的一些微博想到的，开车是之前LD买了车后，陪领导练车，其实在一开始练车的时候，我们已经是找了相对很空的封闭路段，路上基本很少有车，偶尔有一辆车，但是LD还是很害怕，车速还只有十几的时候，还很远的对面来车的时候就觉得很慌了，这个时候如果以常理肯定会说这样子完全不用怕，如果克服恐惧真的这么容易的话，问题就不会那么纠结了，人生是很难完全感同身受的，唯有降低预设的基准让事情从头理清楚，害怕了我们就先休息，有车了我们就停下，先适应完全没车的情况，变得更慢一点，如果这时候着急一点，反而会起到反效果，比如只是说不要怕，接着开，甚至有点厌烦了，那基本这个练车也不太成得了了，而正好是有耐心的一起慢慢练习，还有就是第二件是切身体会，就是当道路本来是两条道，但是封了一条的时候，这时候开车如果是像我这样的新手，如果开车时左右边看着的话，车肯定开不好，因为那样会一直左右调整，反而更容易控制不好左右的距离，蹭到旁边的隔离栏，正确的方式应该是专注于正前方的路，这样才能保证左右边距离尽可能均匀，而不是顾左失右或者顾右失左，所以很多陪伴学习需要注意的是方式和耐心，能够识别到关键点那是最好的，但是有时候更需要的是耐心，纯靠耐心不一定能解决问题，但是可能会找到问题关键点。

0%