Mybatis源码之--XML完整解析流程

Mybatis源码之–XML完整解析流程

如何编译源码

仓库地址

1、idea中打开项目

2、等待解析依赖

备注：解析依赖的过程中有可能某些jar包的版本找不到，可自行在https://mvnrepository.com/ 找寻替代版本

XML解析

mybatis3支持注解方式声明SQL语句，但是最终经过mybatis内部解析，作用和使用XML定义是一样的。

只要你理解了XML的整个解析流程，其实就已经吃透了mybatis。

在阅读源码的过程中，mybatis的中文官网必须时刻去翻阅。特别是如下几章内容：

• 入门
• XML配置
• XML映射器
• 动态SQL

XML配置讲解的是mybatis-config.xml (配置数据库地址、插件、类型别名)

XML映射器讲解的是我们自定义业务SQL语句的***Mapper.xml

如何开始阅读源码呢？当然不可能一个一个包一个一个类去翻阅，这样是没有意义的。我们必须找到一个入口，也就是写一个最简单的例子跑完整个流程。然后使用idea跟踪这个流程的每一步。

可以参照入门搭建一个最小的示例。

入口示例

我参照入门构造了一个示例，目录结构如下：

在mybatis-config.xml中，配置了数据库地址、以及业务mapper xml文件 （projectInfo.xml）

Mybatis-config.xml

<configuration>
  <plugins>
    <plugin interceptor="com.twx.mybatis.interceptor.InterceptorDemo1" />
  plugins>

  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/dashboard_heart_beat"/>
        <property name="username" value="twx"/>
        <property name="password" value="soyuan123"/>
      dataSource>
    environment>
  environments>

  <mappers>
    <mapper resource="com/twx/mybatis/mapper/xml/projectInfo.xml"/>
  mappers>
configuration>

projectInfo.xml

<mapper namespace="com.twx.mybatis.mapper.ProjectInfoMapper">


    <resultMap id="projectInfoMap" type="com.twx.mybatis.entity.ProjectInfo">
        <id column="id" property="id" jdbcType="INTEGER">id>
        <result column="project_name" property="projectName" jdbcType="VARCHAR">result>
        <result column="url" property="url" jdbcType="VARCHAR">result>
        <result column="description" property="description" jdbcType="VARCHAR">result>
        <result column="tags" property="tags" jdbcType="VARCHAR">result>
        <result column="username" property="username" jdbcType="VARCHAR" />
        <result column="password" property="password" jdbcType="VARCHAR" />
        <result column="thumbnail_url" property="thumbnailUrl" jdbcType="VARCHAR" />
        <result column="second_category_id" property="secondCategoryId" jdbcType="INTEGER" />
        <result column="project_sort" property="projectSort" jdbcType="INTEGER" />
        <result column="maintainer" property="maintainer" jdbcType="VARCHAR" />
        <result column="status" property="status" jdbcType="BOOLEAN" />
        <result column="back_service" property="backService" jdbcType="BOOLEAN" />
        <result column="edit" property="edit" jdbcType="BOOLEAN" />
        <result column="create_time" property="createTime" jdbcType="DATE" />
        <result column="update_time" property="updateTime" jdbcType="DATE" />
    resultMap>

    <sql id="info_columns">
        p.id, p.project_name,p.url,p.description,p.tags,
        p.username,p.`password`,p.thumbnail_url,p.second_category_id,
        p.project_sort,p.maintainer,p.`status`,p.back_service,p.create_time
    sql>

    <select id="getProjectInfo" resultMap="projectInfoMap">
        select
        <include refid="info_columns">include>
        from project_info p
        LEFT JOIN second_category sc on sc.id = p.second_category_id
        INNER JOIN primary_category pc on pc.id = sc.p_id
        where p.logic_delete = 0
        <if test="fId != null">
            and pc.id = #{fId}
            <if test="sId !=null">
                and sc.id = #{sId}
            if>
        if>
        ORDER BY pc.sort,sc.sort,p.project_sort
    select>

    
    <resultMap id="projectFrontMap" type="com.twx.mybatis.entity.ProjectFront">
        <result column="project_name" property="projectName" jdbcType="VARCHAR">result>
        <result column="url" property="url" jdbcType="VARCHAR">result>
        <result column="description" property="description" jdbcType="VARCHAR">result>
        <result column="username" property="username" jdbcType="VARCHAR" />
        <result column="password" property="password" jdbcType="VARCHAR" />
        <result column="thumbnail_url" property="thumbnailUrl" jdbcType="VARCHAR" />
        <result column="category" property="category" jdbcType="VARCHAR" />
        <result column="category_sort" property="categorySort" jdbcType="INTEGER" />
        <result column="second_category" property="secondCategory" jdbcType="VARCHAR" />
        <result column="second_category_sort" property="secondCategorySort" jdbcType="INTEGER" />
        <result column="project_sort" property="projectSort" jdbcType="INTEGER" />
        <result column="maintainer" property="maintainer" jdbcType="VARCHAR" />
        <result column="create_time" property="createTime" jdbcType="DATE" />
    resultMap>

    <sql id="front_columns">
        p.project_name,p.url,p.description,p.tags,
        p.username,p.`password`,p.thumbnail_url,
        pc.name as category,pc.sort as category_sort,
        sc.name as second_category,sc.sort as second_category_sort,
        p.project_sort,p.maintainer,p.create_time
    sql>

    <select id="getProjectFront" resultMap="projectFrontMap">
        select
        <include refid="front_columns">include>
        from project_info p
        LEFT JOIN second_category sc on sc.id = p.second_category_id
        INNER JOIN primary_category pc on pc.id = sc.p_id
        WHERE p.back_service=0
        ORDER BY pc.sort,sc.sort,p.project_sort
    select>
mapper>

mybatis解析xml文件的入口是 mybatis-config.xml。

依次解析properties->settings->typeAliases->plugins->objectFactory->objectWrapperFactory->reflectorFactory->environments->databaseIdProvider->typeHandlers->mappers

最后的mapperElement(root.evalNode("mappers")); 解析的就是我们的业务mapper:

我们先来看mybatis-config.xml的解析

mybatis-config.xml

String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
assert inputStream!=null;
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

我们的入口程序中指定了mybatis-config.xml的路径，传递给了SqlSessionFactoryBuilder的build方法。

XMLConfigBuilder1

我们进入看看：

注意XMLConfigBuilder对象，它负责解析mybatis-config.xml中除了mappers标签以外的元素。

我们进入XMLConfigBuilder的构造方法中看看,同时也要注意一下XMLConfigBuilder继承了一个BaseBuilder类：

public class XMLConfigBuilder extends BaseBuilder {

  public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
    //XMLMapperEntityResolver实现了org.xml.EntityResolver接口
    this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
  }
}

注意：构造方法中新建了一个new XPathParser对象，我们不深入这个类，它的作用是可以根据标签方便的获取xml内容。例如parser.evalNode("/configuration")就能获取到configuration中的内容。

<configuration>
  <plugins>
    <plugin interceptor="com.twx.mybatis.interceptor.InterceptorDemo1" />
  plugins>
  <environments default="development">
  environments>
  <mappers>
    <mapper resource="com/twx/mybatis/mapper/xml/projectInfo.xml"/>
  mappers>
configuration>

刚刚看了XMLConfigBuilder的构造方法，我们继续：

仍然还是调用构造方法，注意在构造方法中调用了父类的构造方法，传进了一个新的Configuration对象。

特别说明，Configuration类在mybatis中可是非常非常重要，几乎无处不在。它保存着mybatis-config.xml中的配置信息以及我们业务mapper中的类信息。真的超级重要。

Configuration1

既然这么重要，我们看看new Configuration的时候做了些什么操作吧。

/**
 * 初始化了内置别名、LanguageDriver
 */
public Configuration() {
  typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
  typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

  typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
  typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
  typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);
  ...
    省略了其他
}

因为configuration的内容真的太多了，它有很多成员变量，这些成员变量都是new出来的，所以新建一个configuration对象是个耗时的工作。

TypeAliasRegistry

我们先看看构造器中用到的这个typeAliasRegistry对象吧，它在成员变量中的定义如下：

protected final TypeAliasRegistry typeAliasRegistry = new TypeAliasRegistry();

我们再来看看它：

public class TypeAliasRegistry {

  /**
   * 例子：
   */
  private final Map<String, Class<?>> typeAliases = new HashMap<>();

  public TypeAliasRegistry() {
    registerAlias("string", String.class);

    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    ...
      省略
  }
}

TypeAliasRegistry从它的名称就能知道它的作用：别名注册器，啥意思呢？

比如我在mybaits-config中定义了一个别名 ，最终就会调用TypeAliasRegistry的registerAlias方法

registerAlias(‘Author’,Author.class)

如何使用呢？遇到的时候再告诉你吧。

注意一下：在TypeAliasRegistry构造器中我们初始化了基本类型的别名

---

Configuration2

现在我们回到Configuration1一节的最后，继续。

在Configuration的构造器中我们初始化了

typeAliasRegistry.registerAlias(“POOLED”, PooledDataSourceFactory.class);

typeAliasRegistry.registerAlias(“JDBC”, JdbcTransactionFactory.class);

再来看mybatis-config.xml中的环境变量：

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC"/>
    <dataSource type="POOLED">

    dataSource>
  environment>
environments>

这里提一下，后面我们在解析environments标签的时候会用到我们的别名JDBC、POOLED

---

现在我们回到XMLConfigBuilder1中的构造器：

private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
  //注意：在此new Configuration实例
  super(new Configuration());
  ErrorContext.instance().resource("SQL Mapper Configuration");
  this.configuration.setVariables(props);
  this.parsed = false;
  this.environment = environment;
  this.parser = parser;
}

构造器后续的几条语句就没什么好说的了。

我们又回到了XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);

紧接着调用XMLConfigBuilder的parse方法，正式开始解析mybatis-config.xml

XMLConfigBuilder.parse

因为我们在mybatis-config.xml中只定义了plugins--environments--mappers这几个节点，所以我们就只看这几个节点的解析。（其中settings标签设置了很多默认值，比如下划线转驼峰，可以去看看，这里不讲解）

解析plugins

plugin在mybatis中可是非常出名的，像我们最经常使用的分页插件，入口就在这。

因为这一节只是说xml的解析，所以不能说得太详细。

先贴一下xml中的配置：

<plugins>
  <plugin interceptor="com.twx.mybatis.interceptor.InterceptorDemo1" />
plugins>

private void pluginElement(XNode parent) throws Exception {
  if (parent != null) {
    for (XNode child : parent.getChildren()) {
      //获取plugin节点的interceptor属性
      String interceptor = child.getStringAttribute("interceptor");

      Properties properties = child.getChildrenAsProperties();
      //反射new
      Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor().newInstance();
      interceptorInstance.setProperties(properties);
      //添加到过滤器链interceptorChain中
      configuration.addInterceptor(interceptorInstance);
    }
  }
}

• 获取plugin节点的interceptor属性
• 通过反射生成我们自定义的拦截器（比如分页插件）
• 最后添加到过滤器链中

过滤器链设计得非常巧妙，很精彩。以后再给你们分享。

解析environments

环境变量主要是设置数据库连接地址、用户名、密码等

再贴xml配置：

<environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/dashboard_heart_beat"/>
        <property name="username" value="twx"/>
        <property name="password" value="soyuan123"/>
      dataSource>
    environment>
  environments>

配合着代码看：

我们来看dataSourceElement这个方法，正好把上面提到的TypeAliasRegistry用上：

private DataSourceFactory dataSourceElement(XNode context) throws Exception {
    if (context != null) {
      //这里的type=POOLED
      String type = context.getStringAttribute("type");
      //这里存储用户名、密码、数据库地址
      Properties props = context.getChildrenAsProperties();
      //如果type=POOLED => PooledDataSourceFactory
      //别名注册地：typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
      DataSourceFactory factory = (DataSourceFactory) resolveClass(type).getDeclaredConstructor().newInstance();
      factory.setProperties(props);
      return factory;
    }
    throw new BuilderException("Environment declaration requires a DataSourceFactory.");
  }

请看代码里的注释。

其中resolveClass(type)在这里是resolveClass("POOLED") ,跟踪一下代码就很容易发现，resolveClass(type)最终调用的是typeAliasRegistry.resolveAlias(alias);。

通过resolveClass(type)拿到Class类型后，就能通过反射生成PooledDataSourceFactory实例了。

接下来就是最最复杂的mappers解析了，我们的select、update、delete都定义在此。

---

projectInfoMapper.xml

//映射器--这里面非常复杂--转交给XMLMapperBuilder实现
mapperElement(root.evalNode("mappers"));

配合着xml,来看看mapperElement方法吧:

<mappers>
  <mapper resource="com/twx/mybatis/mapper/xml/projectInfo.xml"/>
mappers>

由于我的演示示例中没有定义package标签，代码不会进入。

此次我会进入红色箭头指示的地方，因为我只定义了resource属性

来看硬核的地方：XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());

XMLMapperBuilder

进入构造方法看看，同时注意它也继承了父类BaseBuilder（之前已经提过了）

同样也new了个XPathParser解析器，跳过。看上图我红框标记的地方：

this.builderAssistant = new MapperBuilderAssistant(configuration, resource);

这也是个非常重要的类，看名字就知道它是个助手类，负责组装SQL用的。很重要很重要

参数：

• configuration： 之前我们在XMLConfigBuilder构造器中new出来的，还有印象吗
• resource: mapper文件路径，这里是com/twx/mybatis/mapper/xml/projectInfo.xml

我们来看看它吧。

MapperBuilderAssistant

public class MapperBuilderAssistant extends BaseBuilder {
  /**
   * xml文件中的命名空间 

   * 例如：
   */
  private String currentNamespace;
  /**
   * mapper xml 文件的全路径
   */
  private final String resource;
  private Cache currentCache;
  private boolean unresolvedCacheRef; // issue #676

  public MapperBuilderAssistant(Configuration configuration, String resource) {
    super(configuration);
    ErrorContext.instance().resource(resource);
    this.resource = resource;
  }
}

它也继承了BaseBuilder，所以它也有一个Configuration对象的引用（还记得我说过的，Configuration对象很重要，后面非常多类都要用到它。

注意它的几个成员变量：

• currentNamespace：业务xml文件中的命名空间
• resource：业务xml 文件的全路径，设置在mybatis-config.xml mapper标签的resource属性中
• currentCache：一级缓存，暂时不讲解

它还有很多重要的方法，这里先列举几个常用的：

• applyCurrentNamespace-返回mapper接口方法的完全限定名称
• useNewCache–创建缓存对象
• addResultMap–生成ResultMap，add到configure对象的resultMaps中
• addMappedStatement–生成MappedStatement对象，set到config对象的mappedStatements中
• getStatementResultMaps–根据resultMap参数从config对象中获取ResultMap对象
• buildResultMapping–构建ResultMapping对象
• resolveResultJavaType-返回java bean属性对应的Java类型

---

XMLMapperBuilder解析

parse

从XMLMapperBuilder构造器出来，紧接着就调用parse方法

XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
mapperParser.parse();

String namespace = context.getStringAttribute("namespace");拿到的是

我们再来看看更具体的configurationElement(XNode context)方法

接下来会着重讲解三个方法：

• resultMapElements
• sqlElement
• buildStatementFromContext

这三个方法对应下图xml文件中的三个标签

resultMapElements1

先来看如何解析resultMap标签的。

真正解析的方法很长。我们分段看。

<resultMap id="projectInfoMap" type="com.twx.mybatis.entity.ProjectInfo">
省略
resultMap>

//type = com.twx.mybatis.entity.ProjectInfo
String type = resultMapNode.getStringAttribute("type",
    resultMapNode.getStringAttribute("ofType",
        resultMapNode.getStringAttribute("resultType",
            resultMapNode.getStringAttribute("javaType"))));

由于只传了一个type属性，所以String type=com.twx.mybatis.entity.ProjectInfo

Class<?> typeClass = resolveClass(type);
if (typeClass == null) {
  typeClass = inheritEnclosingType(resultMapNode, enclosingType);
}

typeClass理所应当是com.twx.mybatis.entity.ProjectInfo

---

再来看上面这段代码，先解释一下ResultMapping.

ResultMapping

一个ResultMapping对应entity中的一个属性，亦即

上图xml中的每一行最后都被解析成一个一个的ResultMapping 对象。

理解了这点，我们回到java代码中的for循环。for循环就是解析这些id,result。由于我们没有定义constructor，discriminator，就跳过这几行代码。直接看id 和 result标签的解析。

我们来看这行代码：

//解析 标签
resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));

来看buildResultMappingFromContext方法，buildResultMappingFromContext 用于生成一个ResultMapping对象。

上图这段java代码对照着下图看就很清晰了，不做过多解析。（注意，我们没对resultMap的每个属性声明typeHandler)

代码最后一行我特别标注，最终ResultMapping对象的生成是转交给builderAssistant助手实现的（前面我们提到过，还有印象吗，当时只是提到了方法名称，并没有具体去分析，现在我们去看看）。

---

我们来看builderAssistant的buildResultMapping方法：

public ResultMapping buildResultMapping(Class<?> resultType, String property, String column, Class<?> javaType, JdbcType jdbcType,
      String nestedSelect, String nestedResultMap, String notNullColumn, String columnPrefix,
      Class<? extends TypeHandler<?>> typeHandler, List<ResultFlag> flags,
      String resultSet, String foreignColumn, boolean lazy) {
    //根据属性property名称例如username获取对应的java类型String
    Class<?> javaTypeClass = resolveResultJavaType(resultType, property, javaType);
    //typeHandler在我们的示例中是null,返回null
    TypeHandler<?> typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);

    //是否有组合对象
    List<ResultMapping> composites;
    //假如
    // 有配置select属性，那么这里的nestedSelect!=null
    //有配置foreignColumn属性，这里的foreignColumn!=null
    //在我们的示例中，显然两者都为空，所以composites=null
    if ((nestedSelect == null || nestedSelect.isEmpty()) && (foreignColumn == null || foreignColumn.isEmpty())) {
      composites = Collections.emptyList();
    } else {
      composites = parseCompositeColumnName(column);
    }

    return new ResultMapping.Builder(configuration, property, column, javaTypeClass)
        .jdbcType(jdbcType)
        .nestedQueryId(applyCurrentNamespace(nestedSelect, true))
        .nestedResultMapId(applyCurrentNamespace(nestedResultMap, true))
        .resultSet(resultSet)
        .typeHandler(typeHandlerInstance)
        .flags(flags == null ? new ArrayList<>() : flags)
        .composites(composites)
        .notNullColumns(parseMultipleColumnNames(notNullColumn))
        .columnPrefix(columnPrefix)
        .foreignColumn(foreignColumn)
        .lazy(lazy)
        .build();
  }

这个方法的作用是为了：

• 确定java bean属性对应的Class类型
• 确定属性交给什么TypeHandler处理
• 以及属性是否有嵌套查询

最后的return语句其实就是new ResultMapping(),只不过用的是建造者模式而已。

---

resultMapElements2

我们回到resultMapElements1一节的最后。

//每一个ResultMapping对应entity中的一个属性
 List<ResultMapping> resultMappings = new ArrayList<>(additionalResultMappings);
for (XNode resultChild : resultChildren) {
  ....
    省略
   //解析 标签
		resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags)); 
}

经过我们上面对ResultMapping的分析，执行完上面这个for循环后，我们继续。

再次贴上xml:

 <resultMap id="projectInfoMap" type="com.twx.mybatis.entity.ProjectInfo">
   ...
   省略了
  resultMap>

看代码注释就好。

最后调用ResultMapResolver.resolve()生成ResultMap对象。

ResultMapResolver.resolve() 最终还是调用我一再强调的助手类MapperBuilderAssistant的addResultMap

public ResultMap resolve() {
  return assistant.addResultMap(this.id, this.type, this.extend, this.discriminator, this.resultMappings, this.autoMapping);
}

我们来看MapperBuilderAssistant.addResultMap()

/**
 * 生成ResultMap，add到configure对象的resultMaps中
 * @param id  resultMapId
 * @param type  mapper返回类型
 * @param extend
 * @param discriminator
 * @param resultMappings
 * @param autoMapping
 * @return
 */
public ResultMap addResultMap(String id, Class<?> type, String extend,
    Discriminator discriminator, List<ResultMapping> resultMappings, Boolean autoMapping) {

  //resultMap的完全限定名称
  //例如：com.twx.mybatis.mapper.ProjectInfoMapper.projectInfoMap
  id = applyCurrentNamespace(id, false);
  
  //TODO: 构造示例研究
  extend = applyCurrentNamespace(extend, true);
  if (extend != null) {
    ...
      省略
  }
  
  //build方法内部做了很多操作，主要是提取ResultMapping中的属性
  //ResultMapping存储了很多@Result的属性
  ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
      .discriminator(discriminator)
      .build();
  configuration.addResultMap(resultMap);
  return resultMap;
}

不需要关心太多，直接看最后new ResultMap.Builder().build()

这个方法不详细讲了，大概的内容就是遍历之前生成的List resultMappings 给自己的成员变量赋值。下面列举几个关键的成员变量。

/**
 * resultMap的id
 */
private String id;
/**
 * 返回类型，例如com.twx.mybatis.entity.ProjectInfo
 */
private Class<?> type;
private List<ResultMapping> resultMappings;
/**
 * id标签对应的ResultMapping
 */
private List<ResultMapping> idResultMappings;
/**
 * 构造器对应的constructorResultMappings
 */
private List<ResultMapping> constructorResultMappings;
/**
 * id+result标签对应的ResultMapping
 */
private List<ResultMapping> propertyResultMappings;

至此，终于完成了 标签的解析了。

---

sqlElement

这是我们的第二大标签。我们先看看xml中的定义与使用。你一定很熟悉。

<sql id="info_columns">
  p.id, p.project_name,p.url,p.description,p.tags,
  p.username,p.`password`,p.thumbnail_url,p.second_category_id,
  p.project_sort,p.maintainer,p.`status`,p.back_service,p.create_time
sql>

<select id="getProjectInfo" resultMap="projectInfoMap">
  select
  <include refid="info_columns">include>
  from project_info p
select>  

代码实现很简单，只是把标签的id和内容存储到sqlFragments。

sqlFragments是Configuration中的sqlFragments引用

sqlFragments的定义：

/**
 * 存储标签语句，key指代id
 */
protected final Map sqlFragments = new StrictMap<>("XML fragments parsed from previous mappers");

注意 sqlFragments.put(id, context); 中的context是一个Xnode节点，后续会拿出来解析的。这里不做处理

---

buildStatementFromContext

最重磅的一个方法了。非常复杂！

做好准备。这是xml解析最后一步了。

那来看buildStatementFromContext：

由于解析select delete insert 等语句比较复杂，转交给单独的类XMLStatementBuilder解析

parseStatementNode()

同样继承了BaseBuilder，构造方法没什么好讲的了。之前都说过了。

注意一下context代表的是xml node节点内容。例如：

<select id="getProjectInfo" resultMap="projectInfoMap">
  select
  <include refid="info_columns">include>
  from project_info p
  LEFT JOIN second_category sc on sc.id = p.second_category_id
  INNER JOIN primary_category pc on pc.id = sc.p_id
  where p.logic_delete = 0
  <if test="fId != null">
    and pc.id = #{fId}
    <if test="sId !=null">
      and sc.id = #{sId}
    if>
  if>
  ORDER BY pc.sort,sc.sort,p.project_sort
select>

---

我们直接来看parseStatementNode(),这方法也是超级的长。慢慢分析。

String id = context.getStringAttribute("id");
String databaseId = context.getStringAttribute("databaseId");

id在此是getProjectInfo，databaseId=null

---

String nodeName = context.getNode().getNodeName();
SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));

nodeName是select insert update delete其中一种，在此是select

sqlCommandType=SqlCommandType.SELECT

---

boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
//将其设置为 true 后，只要语句被调用，都会导致本地缓存和二级缓存被清空，默认值：false。
boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
//将其设置为 true 后，将会导致本条语句的结果被二级缓存缓存起来，默认值：对 select 元素为 true。
boolean useCache = context.getBooleanAttribute("useCache", isSelect);
//这个设置仅针对嵌套结果 select 语句：如果为 true，将会假设包含了嵌套结果集或是分组，当返回一个主结果行时，就不会产生对前面结果集的引用。
//这就使得在获取嵌套结果集的时候不至于内存不够用。默认值：false。
boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

看代码中的注释。针对select查询语句，useCache默认是true

---

//解析include语句
XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
includeParser.applyIncludes(context.getNode());

上面两行用于解析标签，例如示例中的：

select
<include refid="info_columns">include>
from project_info p

上面替换标签的方法使用到了递归，最核心的是第一个红色框里的代码，找到include对应的标签，然后替换内容。因为递归的原因，不太好通过文字讲解。（可以自己调试代码感受）

---

我们继续回到parseStatementNode()

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

String lang = context.getStringAttribute("lang");
//如果未指定，默认是XMLLanguageDriver
//初始化new Configuration时
//languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
LanguageDriver langDriver = getLanguageDriver(lang);

parameterType我们没传，所以parameterType=null

LanguageDriver langDriver 默认是XMLLanguageDriver，看注释

---

//
//    select CAST(RANDOM()*1000000 as INTEGER) a from SYSIBM.SYSDUMMY1
//  
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 {
  //（仅适用于 insert 和 update）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键
  // （比如：像 MySQL 和 SQL Server 这样的关系型数据库管理系统的自动递增字段），默认值：false。
  keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
      configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
      ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
}

过程就不讲了。不重要。

keyStatementId="com.twx.mybatis.mapper.ProjectInfoMapper.getProjectInfo!selectKey"

KeyGenerator keyGenerator = NoKeyGenerator

---

//如果是动态的，返回DynamicSqlSource
//如果是静态的，返回RawSqlSource
//SqlSource接口有一个方法BoundSql getBoundSql(Object parameterObject);
//能拿到BoundSql
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

这里面也是非常复杂的。如果你的select语句中有if | foreach | trim| when (...) 或者 ${} 那就是动态的，否则是静态的。

如果是动态的，返回DynamicSqlSource

如果是静态的，返回RawSqlSource

我们来看看XMLLanguageDriver的createSqlSource

@Override
public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
  XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
  return builder.parseScriptNode();
}

内部又借助XMLScriptBuilder的parseScriptNode()实现。

那我们转战战场。

XMLScriptBuilder

• 同样继承了BaseBuilder
• 构造方法中调用了initNodeHandlerMap()
• initNodeHandlerMap内部有些TrimHandler之类的东西，这些是内部类

我们来看parseScriptNode()方法：

public SqlSource parseScriptNode() {
  //解析标签中的动态变量
  //MixedSqlNode 维护者一个列表List contents，
  // contents可能包含 StaticTextSqlNode和IfSqlNode或者WhereSqlNode或者其他
  MixedSqlNode rootSqlNode = parseDynamicTags(context);
  SqlSource sqlSource;
  if (isDynamic) {
    sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
  } else {
    sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
  }
  return sqlSource;
}
 
  
parseDynamicTags(context)的作用是解析标签中的动态变量。
 
  
返回的MixedSqlNode维护着一个列表List contents，contents可能包含 StaticTextSqlNode和IfSqlNode或者WhereSqlNode或者其他。
 
  
 
  
我们粗略地看看parseDynamicTags(context)就行，内部的textSqlNode.isDynamic()非常复杂的。主要是数据处理。
 
  
 
  
 
  
解析完parseDynamicTags，必然是动态的（我们的示例），所以返回DynamicSqlSource
 
  
 
  
 
  
parseStatementNode()2
 
  
那我们继续回到parseStatementNode()的这个地方：
 
  
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
 
  
继续往下看。
 
  
 
  
如果未指定，默认是StatementType.PREPARED
 
  
这非常重要，在真正取数据的时候，会根据这个枚举类型new不同的statementHandler对象
 
  
详情参照RoutingStatementHandler构造器
 
  
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());
  }
 
  
在此我们只要知道StatementType statementType=StatementType.PREPARED,用到的时候再细聊。
 
  
 
  
接下来的这些代码没什么好说的，都是从xml配置取值。
 
  
 
  
 
  
parseStatementNode()方法的最后就是生产MappedStatement对象。
 
  
一个MappedStatement对象就代表着你定义的一个 或者或者等等
 
  
//非常重要： 生成MappedStatement对象，set到config对象的mappedStatements中
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
    fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
    resultSetTypeEnum, flushCache, useCache, resultOrdered,
    keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
 
  
我们结合idea看一下具体传进来的是些什么参数吧：
 
  
 
  
结合着上图的参数，我们来看看builderAssistant.addMappedStatement内部代码
 
  
 
  
无它–建造者模式生成MappedStatement对象
 
  
注意，最后把生成的statement添加到了Configuration对象中去了，即：
 
  
/**
 * 很重要：用于存储select insert 等语句
 */
protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection")
    .conflictMessageProducer((savedValue, targetValue) ->
        ". please check " + savedValue.getResource() + " and " + targetValue.getResource());
 
  
添加到了Configuration对象的mappedStatements容器中。key是语句的id,即getProjectInfo
 
  
 
  
生成了MappedStatement后，xml解析工作基本已经完结了，剩下的都是收尾工作。
 
  
顺着堆栈一步步弹出。我们回到了下图这里，即XMLMapperBuilder.parse()：
 
  
 
  
所有xml文件都已经解析完毕了。
 
  
然后标记一下我们已经解析过的xml文件，避免重复加载，毕竟很耗时。
 
  
configuration.addLoadedResource(resource);
 
  
 
  
然后就是这行代码bindMapperForNamespace();
 
  
它的作用是将我们声明的***Mapper.java接口添加到Configuration对象的mapperRegistry成员变量中。
 
  
我们示例声明的接口是ProjectInfoMapper：
 
  
public interface ProjectInfoMapper {
  List<ProjectFront> getProjectFront();
  List<ProjectInfo> getProjectInfo(@Param("fId") Integer fId, @Param("sId") Integer sID);
}
 
  
调用bindMapperForNamespace 后，相当于
 
  
protected final MapperRegistry mapperRegistry = new MapperRegistry(this);
mapperRegistry.addMapper(ProjectInfoMapper.class);
 
  
 
  
parsePendingResultMaps();
parsePendingCacheRefs();
parsePendingStatements();
 
  
这几个方法就不说了。
 
  
至此，xml解析流程全部完毕。
 
  
接下来，我们看看mybatis是如何查询的。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(Java)
        

            

                

                    
Long类型前后端数据不一致
                        igotyback
前端
                        
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
                    
                    
LocalDateTime 转 String
                        igotyback
java开发语言
                        
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
                    
                    
Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
                    
                    
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
                    
                    
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
                    
                    
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
                    
                    
HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
                    
                    
node.js学习
                        小猿L
node.jsnode.js学习vim
                        
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
                    
                    
Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
                    
                    
简单了解 JVM
                        记得开心一点啊
jvm
                        
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
                    
                    
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
                    
                    
Java企业面试题3
                        马龙强_
java
                        
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
                    
                    
JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
                    
                    
Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
                    
                    
白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
                    
                    
python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
                    
                    
ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
                    
                    
Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
                    
                    
Java：爬虫框架
                        dingcho
Javajava爬虫
                        
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
                    
                    
python怎么将png转为tif_png转tif
                        weixin_39977276

                        
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
                    
                    
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
                    
                    
JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
                    
                    
WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
                    
                    
博客网站制作教程
                        2401_85194651
javamaven
                        
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
                    
                    
00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
                    
                    
JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
                    
                    
JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
                    
                    
切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
                    
                    
【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
                    
                    
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
                    
                                
PHP，安卓，UI，java，linux视频教程合集
                                    cocos2d-x小菜
javaUIlinuxPHPandroid
                                    
╔-----------------------------------╗┆                           
                                
                                
zookeeper admin 笔记
                                    braveCS
zookeeper
                                    
  
Required Software 
1) JDK>=1.6 
2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 
3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘 
   


数据和日志目录  
1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
                                
                                
Spring配置多个连接池
                                    easterfly
spring
                                    
项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ 
Spring中有关于dataSource的配置： 
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 
  &nb
                                
                                
Mysql
                                    171815164
mysql
                                    
例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 
 
GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI 
 
TH GRANT OPTION; 
 
如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
                                
                                
CommonDAO（公共/基础DAO）
                                    g21121
DAO
                                    
        好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。 
        DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
                                
                                
直言有讳
                                    永夜-极光
感悟随笔
                                    
  
1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313 
  
精华: 
“直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
                                
                                
安装CentOS 7 和Win 7后，Win7 引导丢失
                                    随便小屋
centos
                                    
一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。 
一、首先具有root 的权限。 
     即进入Terminal后输入命令su，然后输入密码即可 
二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 
v
                                
                                
Oracle备份与恢复案例
                                    aijuans
oracle
                                    
Oracle备份与恢复案例 
一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
                                
                                
JavaEE开源快速开发平台G4Studio v5.0发布
                                    無為子

                                    
  
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。 
  
访问G4Studio网站  
http://www.g4it.org       
2013-04-06 发布G4Studio_V5.0版本 
功能新增 
(1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
                                
                                
Oracle显示根据高考分数模拟录取
                                    百合不是茶
PL/SQL编程oracle例子模拟高考录取学习交流
                                    
题目要求: 
1,创建student表和result表
2,pl/sql对学生的成绩数据进行处理
3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选 
  
  
1,创建student表,和result表 
学生信息表; 
create table student(
   student_id number primary key,--学生id
                                
                                
优秀的领导与差劲的领导
                                    bijian1013
领导管理团队
                                    
责任 

  优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。 
  
 差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。 
 
努力工作 

  优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
                                
                                
js函数在浏览器下的兼容
                                    Bill_chen
jquery浏览器IEDWRext
                                    
  做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同： 
 
  IE6：node.nextSibling,对于FF是不能识别的； 
 
  FF：node.nextElementSibling,对于IE是不能识别的； 
 
兼容解决方式：var Div = node.nextSibl
                                
                                
【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC)
                                    bit1129
垃圾回收
                                    
吞吐量与用户线程暂停时间 
  
衡量垃圾回收算法优劣的指标有两个： 
 
 吞吐量越高，则算法越好 
 暂停时间越短，则算法越好 
 
首先说明吞吐量和暂停时间的含义。 
  
垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
                                
                                
J2EE监听器和过滤器基础
                                    白糖_
J2EE
                                    
 Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。 
监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。 
  
 
 ServletContex监听器 
   ServletContex又叫application
                                
                                
博弈AngularJS讲义(16) - 提供者
                                    boyitech
jsAngularJSapiAngularProvider
                                    
  Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。 
  那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
                                
                                
java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。
                                    bylijinnan
java
                                    


public class CommonSubSequence {

	/**
	 * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。
	 * 写一个版本算法复杂度O(N^2)和一个O(N) 。
	 * 
	 * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。
	 * O(
                                
                                
sqlserver 2000 无法验证产品密钥
                                    Chen.H
sqlwindowsSQL ServerMicrosoft
                                    
在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。 这样做, 收到以下错误信息CD KEY的 SQ
                                
                                
[新概念武器]气象战争
                                    comsci

                                    
 
 
       气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织.... 
 
       原因如下: 
 
       地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
                                
                                
oracle 中 rollup、cube、grouping 使用详解
                                    daizj
oraclegroupingrollupcube
                                    
oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示 转自namesliu 
 
-- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景  
  
--- ROLLUP ， 为了理解分组的成员数量，我增加了 分组的计数  COUNT(SAL)  
 
                                
                                
技术资料汇总分享
                                    Dead_knight
技术资料汇总 分享
                                    
本人汇总的技术资料，分享出来，希望对大家有用。 
 
http://pan.baidu.com/s/1jGr56uE 
 
资料主要包含： 
Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) 
Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) 
Ser
                                
                                
初一下学期难记忆单词背诵第一课
                                    dcj3sjt126com
englishword
                                    
could 能够 
minute 分钟 
Tuesday 星期二 
February 二月 
eighteenth 第十八 
listen 听 
careful 小心的，仔细的 
short 短的 
heavy 重的 
empty 空的 
certainly 当然 
carry 携带；搬运 
tape 磁带 
basket 蓝子 
bottle 瓶 
juice 汁，果汁 
head 头；头部 

                                
                                
截取视图的图片, 然后分享出去
                                    dcj3sjt126com
OSObjective-C
                                    
OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. 
I implemented a category method on UIView to get the vi
                                
                                
MySql重置密码
                                    fanxiaolong
MySql重置密码
                                    
方法一: 
 在my.ini的[mysqld]字段加入： 
skip-grant-tables 
重启mysql服务，这时的mysql不需要密码即可登录数据库 
 然后进入mysql 
mysql>use mysql; 
 mysql>更新 user set password=password('新密码') WHERE User='root'; 
mysq
                                
                                
Ehcache（03）——Ehcache中储存缓存的方式
                                    234390216
ehcacheMemoryStoreDiskStore存储驱除策略
                                    
Ehcache中储存缓存的方式 
  
目录 
1     堆内存（MemoryStore） 
1.1     指定可用内存 
1.2     驱除策略 
1.3     元素过期 
2   &nbs
                                
                                
spring mvc中的@propertysource
                                    jackyrong
spring mvc
                                    
  在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： 
 
@PropertySource  在spring 3.1中开始引入 
 
比如有配置文件 
config.properties 
 
mongodb.url=1.2.3.4 
mongodb.db=hello 
 
则代码中 
  

@PropertySource(&
                                
                                
重学单例模式
                                    lanqiu17
单例Singleton模式
                                    
最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。 
	第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。
	单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式
	静态内部类方式: 
package test.pattern.singleton.statics;

publ
                                
                                
.NET开源核心运行时，且行且珍惜
                                    netcome
java.net开源
                                    
背景 
2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
                                
                                
使用oscahe缓存技术减少与数据库的频繁交互
                                    Everyday都不同
Web高并发oscahe缓存
                                    
此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。 
  
缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
                                
                                
Spring+Mybatis 手动控制事务
                                    toknowme
mybatis
                                    
@Override 
   public boolean testDelete(String jobCode) throws Exception { 
      boolean flag = false; 
 &nbs
                                
                                
菜鸟级的android程序员面试时候需要掌握的知识点
                                    xp9802
android
                                    
熟悉Android开发架构和API调用 
掌握APP适应不同型号手机屏幕开发技巧 
熟悉Android下的数据存储  
熟练Android Debug Bridge Tool 
熟练Eclipse/ADT及相关工具  
熟悉Android框架原理及Activity生命周期 
熟练进行Android UI布局 
熟练使用SQLite数据库； 
熟悉Android下网络通信机制，S
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

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