MyBatis

目录

Mybatis结构

MyBatis分页方式

逻辑分页

物理分页

分页插件(PageHelper)

Mybatis代码生成器

添加依赖

新建工具类

Mybatis通用方法

Mybatis初始化

BaseBuilder

XMLConfigBuilder

XMLMapperBuilder

XMLStatementBuilder

绑定 Mapper 接口

---

生如蝼蚁 当立鸿鹄之志 命薄如纸 应有不屈之心 大丈夫生于天地间 岂能郁郁久居人下 乾坤未定 你我皆是黑马

iBATIS

iBATIS一词来源于"internet"和"abatis"的组合，是apache的一个开源项目(由Clinton Begin在2001年发起的开放源代码项目)。 于2010年6月16号这个项目由apache software foundation 迁移到了google code(被谷歌托管)并且改名为MyBatis ，2013年11月迁移到Github。是一个基于SQL映射支持Java和.NET的持久层框架，使用XML或注解来配置和映射原生信息，将接口和Java的POJO(Plain Ordinary Java Object，普通的Java对象)映射成数据库中的记录。查看ibatis官网：

iBATIS HomeiBATIS Data Mapping Framework for Java and .NEThttps://ibatis.apache.org/会发现有如下提示：

Mybatis

mybatis是一个优秀的基于java语言开发的持久层开源框架，内部封装jdbc，开发者只需要关注sql 语句本身，不需要加载驱动、创建连接、创建statement等操作。通过xml文件或注解的方式将要执行的各种statement配置起来，然后java对象和statement中sql的动态参数进行映射生成最终执行的sql语句，由mybatis框架执行sql并将结果映射为java对象并返回。采用ORM(Object relational mapping)思想解决了实体和数据库映射的问题，对jdbc的封装，屏蔽了jdbc api底层访问细节，不用与jdbc api打交道就可以完成对数据库的持久化操作，简化开发。以前用JDBC是这样的：

public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            //加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            //通过驱动管理类获取数据库链接
            connection = DriverManager
            .getConnection("jdbc:mysql://localhost:3306/mybatis?
            characterEncoding=utf-8", "root", " root");
            //定义 sql 语句 ?表示占位符
            String sql = "select * from user where username = ?";
            //获取预处理 statement
            preparedStatement = connection.prepareStatement(sql);
            //设置参数，第一个参数为 sql 语句中参数的序号（从 1 开始）
            //第二个参数为设置的参数值
            preparedStatement.setString(1, "王五");
            //向数据库发出 sql 执行查询，查询出结果集
            resultSet = preparedStatement.executeQuery();
            //遍历查询结果集
            while (resultSet.next()) {      
            System.out.println(resultSet.getString("id")+""
            +resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //释放资源
            if (resultSet != null) {
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
}

数据库连接创建、连接释放操作频繁会造成系统资源的浪费影响系统性能，使用数据库连接池解决了此问题。Sql语句在代码中硬编码，代码不易维护。例如结果集解析(查询列名)sql变化导致解析代码变更。Mybatis内置数据库连接池、提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试、提供XML标签，支持编写动态sql，sql语句写在xml文件里面，便于统一进行管理。

mybatis – MyBatis 3 | Introductionhttps://mybatis.org/mybatis-3/

Mybatis-Plus

MyBatis-Plus (opens new window)（简称 MP）在MyBatis的基础上只做增强不做改变，为简化开发、提高效率而生。MyBatis-PlusMyBatis-Plus 官方文档https://baomidou.com/

1、无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作BaseMapper。
2、强大的CRUD操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD操作，更有强大的条件构造器，满足各类使用需求，简单的CRUD操作不用自己编写。
3、支持Lambda形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错。
4、支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题。
5、支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作。
6、支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
7、内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用（自动生成代码）。
8、内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询。
9、分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库。
10、内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询。
11、内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作。

Mybatis结构

Mybatis持久层框架具有轻量级、解耦(业务逻辑和数据访问分离，使系统结构更清晰，易维护，更易单元测试)的特点，分为以下几层：

API接口层：提供一些API接口，通过这些API接口来操纵数据库，接口层收到调用请求会调用数据处理层来完成具体的数据处理。

数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等,主要目的是根据调用的请求完成一次数据库操作。

基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的功能，将他们抽取出来作为最基础的组件，为上层的数据处理层提供最基础的支撑。

IBatis与MyBatis

在sqlMap里面，iBatis的传入参数是parameterClass，而MyBatis是可以不写的，也可以用parameterType，iBatis的传出参数是resultClass

iBatis：



MyBatis：

 

条件判断语句对于MyBatis很简单，标签里面写判断条件即可。但是IBatis就麻烦了许多，它将每个方法都进行了封装

例如：
isNull：判断property字段是否是null        


isEqual相当于equals，判断状态值。

  或
  

isEmpty判断参数是否为Null或者空，满足其中一个条件则其true。
isNotEmpty相反，当参数既不为Null也不为空时其为true。 
        
Ibatis：
  
         username=#userNameList[]#  

  
Mybaits：

         #{item.id}

#{}和${}

select * from user where name = #{name};
select * from user where name = ${name};

//解析后结果为:
select * from user where name = 'zhangsan';

//#{}和${}在预编译中的处理是不一样的,#{}在预处理时会把参数部分用一个占位符?代替，变成:
select * from user where name = ?;
//${}则只是简单的字符串替换，在动态解析阶段sql语句会被解析成：
select * from user where name = 'zhangsan';

//#{}的参数替换是发生在DBMS中，而${}发生在动态解析过程中,${}会导致sql注入的问题。

MyBatis和Hibernate

灵活性

MyBatis操作灵活，使用起来比较方便。hibernate是全自动，而mybatis是半自动。hibernate可以通过对象关系模型实现对数据库的操作，通过实体对象与数据库的表进行映射来自动生成sql。而mybatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过手写sql来实现和管理

可移植性

Hibernate数据库移植性远大于Mybatis。hibernate通过它强大的映射结构和hql语言，大大降低了对象与不同数据库（oracle、MySQL等）的耦合性，而mybatis由于需要手写sql，因此sql中很容易包含一些不同的数据库不兼容的函数或者语法，移植性也会随之降低很多，成本很高.

优化上

在sql优化上，mybatis要比hibernate方便一些，由于mybatis的sql都是写在xml里，因此优化sql比hibernate方便很多。而hibernate的sql很多都是自动生成的，无法直接维护sql；虽有hql，但功能还是不及sql强大，像报表等需求时，hql满足不了需求；hibernate虽然也支持原生sql，但开发模式上却与orm不同，需要转换思维，因此使用上不是非常方便。总之写sql的灵活度上hibernate不及mybatis。

二级缓存

hibernate拥有更好的二级缓存，它的二级缓存可以自行更换为第三方的二级缓存。

MyBatis分页方式

逻辑分页

使用MyBatis自带的RowBounds进行分页，一次性查询很多数据，然后在结果中检索分页的数据。这样弊端是需要消耗大量的内存、有内存溢出的风险、对数据库压力较大。 RowBounds不是一次性查询全部结果，因为MyBatis是对jdbc的封装，在jdbc驱动中有一个Fetch Size的配置，它规定了每次最多从数据库查询多少条数据，假如你要查询更多数据，它会在你执行next()的时候，去查询更多的数据。

物理分页

自己手写SQL分页或使用分页插件PageHelper，从数据库查询指定条数的数据。

原理

分页插件的基本原理是使用MyBatis提供的插件接口，实现自定义插件，在插件的拦截方法内拦截待执行的SQL，然后重写SQL，根据dialect方言，添加对应的物理分页语句和物理分页参数。

分页插件(PageHelper)

        //maven依赖
          
            com.github.pagehelper  
            pagehelper  
            5.1.8  
        
            com.github.pagehelper
            pagehelper-spring-boot-starter
            1.2.10
        

分页

       SqlSession sqlSession = sessionFactory.openSession();
       UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
       PageHelper.startPage(1,10,true);  //第一页 每页显示10条
       Page page=userMapper.findUserAll();

不分页

       PageHelper.startPage(1,-1,true);

查询总条数

       PageInfo  info=new PageInfo<>(userMapper.findUserAll());

Mybatis代码生成器

添加依赖

            
                com.baomidou
                mybatis-plus-generator
                3.3.0
            
            
                mysql
                mysql-connector-java
                5.1.25
            
            
                org.apache.velocity
                velocity-engine-core
                2.0
            

新建工具类

        public class Generator {
              public static void main(String[] args) throws IOException {
                  AutoGenerator mpg = new AutoGenerator();// 代码生成器
                  GlobalConfig gc = new GlobalConfig(); // 全局配置
                  String projectPath = "D:\\parkson-platform-dev\\account"; //当前项目路径
                  gc.setOutputDir(projectPath + "/src/main/java");//输出路径
                  gc.setAuthor("parkson");//作者
                  gc.setOpen(false);
                  gc.setSwagger2(true);//实体属性 Swagger2 注解
                  mpg.setGlobalConfig(gc);
                  DataSourceConfig dsc = new DataSourceConfig();// 数据源配置
                  //设置数据库地址
                  dsc.setUrl("jdbc:mysql://200.86.3.85:8003/parkson_account_dev?serverTimezone=UTC&characterEncoding=UTF-8");
                  //dsc.setSchemaName("public");
                  dsc.setDriverName("com.mysql.jdbc.Driver");
                  dsc.setUsername("root");
                  dsc.setPassword("parkson1016");
                  mpg.setDataSource(dsc);
                  PackageConfig pc = new PackageConfig();// 包配置
                  // pc.setModuleName(scanner("模块名"));
                  pc.setModuleName("");
                  pc.setParent("com.parkson.platform.account");//生成的代码路径
                  mpg.setPackageInfo(pc);

                  // 自定义配置
                  InjectionConfig cfg = new InjectionConfig() {
                      @Override
                      public void initMap() {
                          // to do nothing
                      }
                  };

                  // 配置自定义输出模板
                  String templatePath = "/templates/mapper.xml.vm";
                  List focList = new ArrayList<>();
                  focList.add(new FileOutConfig(templatePath) {
                      @Override
                      public String outputFile(TableInfo tableInfo) {
                          // 自定义输出文件名
                          return projectPath + "/src/main/resources/mapper/"
                                  + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
                      }
                  });
                  cfg.setFileOutConfigList(focList);
                  mpg.setCfg(cfg);

                  // 配置模板
                  TemplateConfig templateConfig = new TemplateConfig();
                  templateConfig.setXml(null);
                  mpg.setTemplate(templateConfig);

                  // 策略配置
                  StrategyConfig strategy = new StrategyConfig();
                  strategy.setNaming(NamingStrategy.underline_to_camel);
                  strategy.setColumnNaming(NamingStrategy.underline_to_camel);;
                  strategy.setEntityLombokModel(true);
                  strategy.setRestControllerStyle(true);
                  strategy.setControllerMappingHyphenStyle(true);
                  strategy.setTablePrefix(pc.getModuleName() + "_");
                  strategy.setInclude("t_vcard");
                  mpg.setStrategy(strategy);
                  //mpg.setTemplateEngine(new VelocityTemplateEngine());
                  mpg.execute();
              }
      }

示例2：

    
        com.oracle
        ojdbc7
        12.1.0.2
    
  /**
   * Oracle数据库
   * mybatis-plus代码生成器
   */
  public class Generator {

      public static void main(String[] args) {
          AutoGenerator mpg = new AutoGenerator();

          // 全局配置
          GlobalConfig gc = new GlobalConfig();
          gc.setOutputDir("E:\\Mybatis_Plus");// 生产文件所在的目录
          gc.setFileOverride(true); // 默认 false ,是否覆盖已生成文件
          gc.setOpen(false); //默认true ,是否打开文件生产所在的目录
          gc.setIdType(IdType.ASSIGN_UUID); // 指定生成的主键类型
          gc.setActiveRecord(true);
          gc.setEnableCache(false);// XML 二级缓存
          gc.setBaseResultMap(true);// XML ResultMap
          gc.setBaseColumnList(false);// XML columList
          gc.setAuthor("[email protected]");
          // 生成文件命名('%s'会自动填充表名)
          gc.setMapperName("%sMapper");
          gc.setXmlName("%sMapper");
          gc.setServiceName("%sService");
          gc.setServiceImplName("%sServiceImpl");
          gc.setControllerName("%sController");
          gc.setSwagger2(true);
          mpg.setGlobalConfig(gc);

          // 数据源配置
          DataSourceConfig dsc = new DataSourceConfig();
          dsc.setDbType(DbType.ORACLE);
          dsc.setDriverName("oracle.jdbc.driver.OracleDriver");
          dsc.setUsername("qms");
          dsc.setPassword("csotqms1129");
          dsc.setUrl("jdbc:oracle:thin:@10.108.234.130:1521:d2pidb1");
          mpg.setDataSource(dsc);

          // 策略配置
          StrategyConfig strategy = new StrategyConfig();
          //strategy.setTablePrefix(new String[]{"D_"});// 设置表前缀
          strategy.setNaming(NamingStrategy.underline_to_camel);// 表名生成策略
          strategy.setInclude(new String[]{"QMS_LAB_APP_RESULTS"}); // 需要生成的表
          mpg.setStrategy(strategy);

          // 文件生产所在目录配置
          PackageConfig pc = new PackageConfig();
          pc.setParent("com.csot.qms");
          pc.setEntity("entity");
          pc.setMapper("mapper");
          pc.setXml("mapper");
          pc.setService("service");
          pc.setServiceImpl("service.impl");
          pc.setController("controller");
          mpg.setPackageInfo(pc);

          // 注入自定义配置，可以在VM中使用cfg.abc设置的值
          InjectionConfig cfg = new InjectionConfig() {
              @Override
              public void initMap() {
              }
          };
          // 配置模板
          TemplateConfig tc = new TemplateConfig();
          // templates/entity.java 模板路径配置，默认在templates目录下，.vm 后缀不用加
          tc.setEntity("templates/entity.java");//使用自定义模板生成实体类
          tc.setXml("");
          //mpg.setTemplate(tc);
          mpg.setCfg(cfg);
          // 执行生成
          mpg.execute();
          // 打印注入设置
          //System.err.println(mpg.getCfg().getMap().get("abc"));
      }
  }

Mybatis通用方法

tk.mybatis包提供通用的增删改查的方法

        
        
            tk.mybatis
            mapper
            4.0.4
        

更新

根据主键更新数据，更新NULL的字段，

updateByPrimaryKey(T var1) 

根据主键更新有值的数据，

updateByPrimaryKeySelective(T var1)

根据Condition条件更新实体record包含的全部属性，null值会被更新，

updateByCondition(@Param("record") T var1, @Param("condition") Object var2) 

根据Condition条件更新实体record包含的不是null的属性值，

updateByConditionSelective(@Param("record") T var1, @Param("condition") Object var2) 

根据Example条件更新实体record包含的不是null的属性值，

updateByExampleSelective(@Param("record") T var1, @Param("example") Object var2)

根据Example条件更新实体record包含的全部属性，null值会被更新，

updateByExample(@Param("record") T var1, @Param("example") Object var2)

根据主键批量修改。

updateListByPrimaryKey(List recordList);

根据指定条件更新指定字段的情况上面几种方法可能都不满足，就只能自己写sql了。

       updateStatusByPrimaryKey(InsureOrgSchemesInfo insureOrgSchemesInfo)；
       
               update INSURE_ORG_SCHEMES_INFO a
               
                   
                       a.state = #{state}
                   
               
               where a.id = #{id}
       

插入

批量新增

insertList(List var1)：

所有的字段都会添加一遍，即使有的字段没有值

insert(T var1) 

只给有值的字段赋值（会对传进来的值做非空判断）

insertSelective(T var1) 

insert和insertSelective在数据库中的效果是一样的，只是sql语句不同。
insertUseGeneratedKeys()：
官网文档：MySQL :: MySQL 5.6 Reference Manual :: 13.2.5.2 INSERT ... ON DUPLICATE KEY UPDATE Statement

删除

delete(T var1)；

     DELETE FROM db_test.t_test_table 
     
       
       AND id = #{id}
      
       
      AND col = #{col}
      
     

deleteByPrimaryKey(Object var1):

    DELETE FROM db_test.t_test_table 
     
     AND id = #{id}
    

根据条件删除

deleteByExample(Object var1) 

Example example = new Example(User.class);
Example.Criteria criteria = example.createCriteria();
criteria.andEqualTo("name","王小二");//相当于 where name = "王小二"
deleteByExample(example );

查询

根据条件查询，作非空判断。

select(T var1) 

根据条件查询 查询行数

selectCount(T var1)

查询全部

selectAll() 

根据Example条件查询

selectByExample(Object var1)

根据Example条件查询行数

selectCountByExample(Object var1)

根据条件查询一个

selectOne(T var1)

selectOneByExample(Object var1)

根据example条件和RowBounds进行分页查询

selectByExampleAndRowBounds(Object var1, RowBounds var2)

根据实体条件和RowBounds进行分页查询

selectByRowBounds(T var1, RowBounds var2)

根据主键查询

selectByPrimaryKey(Object var1) 

Mybatis初始化

和Spring框架的IoC容器初始化 一样，Mybatis也会通过解析相应的配置文件完成自己的初始化。Mybatis 的配置文件主要有 mybatis-config.xml 核心配置文件 及一系列映射配置文件，另外，Mybatis 也会根据注解进行配置。

BaseBuilder

Mybatis 初始化 的主要内容是加载并解析 mybatis-config.xml 配置文件、映射配置文件以及相关的注解信息。Mybatis 的初始化入口是 SqlSessionFactoryBuilder 的 build()方法。

public class SqlSessionFactoryBuilder {

  public SqlSessionFactory build(Reader reader) {
    return build(reader, null, null);
  }

  public SqlSessionFactory build(Reader reader, String environment) {
    return build(reader, environment, null);
  }

  public SqlSessionFactory build(Reader reader, Properties properties) {
    return build(reader, null, properties);
  }

  /**
   * build()方法 的主要实现
   */
  public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
    try {
      // SqlSessionFactory 会创建 XMLConfigBuilder对象 来解析 mybatis-config.xml配置文件
      // XMLConfigBuilder 继承自 BaseBuilder抽象类，顾名思义这一系的类使用了 建造者设计模式
      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
      // 解析配置文件的内容 到 Configuration对象，根据 Configuration对象
      // 创建 DefaultSqlSessionFactory对象，然后返回
      return build(parser.parse());
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
      ErrorContext.instance().reset();
      try {
        // 关闭配置文件输入流
        reader.close();
      } catch (IOException e) {
        // Intentionally ignore. Prefer previous error.
      }
    }
  }

  public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

BaseBuilder

public abstract class BaseBuilder {

  // 保存了 Mybatis 的几乎所以核心配置信息，全局唯一
  protected final Configuration configuration;
  // 在 mybatis-config.xml 中可以通过 标签 定义别名
  protected final TypeAliasRegistry typeAliasRegistry;
  // 在 mybatis-config.xml 中可以通过 标签 添加 自定义TypeHandler
  // TypeHandler 用于完成 JDBC数据类型 与 Java类型 的相互转换，所有的 TypeHandler
  // 都保存在 typeHandlerRegistry 中
  protected final TypeHandlerRegistry typeHandlerRegistry;

  public BaseBuilder(Configuration configuration) {
    this.configuration = configuration;
    this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
    this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
  }
}

BaseBuilder 中的 typeAliasRegistry 和 typeHandlerRegistry 字段 均来自于 configuration，通过 BaseBuilder 的构造方法可以看到详细内容

XMLConfigBuilder

XMLConfigBuilder 是 BaseBuilder 的众多子类之一，主要负责解析 mybatis-config.xml 配置文件。它通过调用 parseConfiguration()方法 实现整个解析过程，其中，mybatis-config.xml 配置文件 中的每个节点都被封装成了一个个相应的解析方法，parseConfiguration()方法 只是依次调用了这些解析方法而已。

public class XMLConfigBuilder extends BaseBuilder {

  // 标记是否解析过 mybatis-config.xml文件
  private boolean parsed;
  // 用于解析 mybatis-config.xml 的解析器
  private final XPathParser parser;
  // 标识 配置 的名称，默认读取 标签 的 default属性
  private String environment;
  // 创建并缓存 Reflector对象
  private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();

  /**
   * 解析的入口，调用了 parseConfiguration() 进行后续的解析
   */
  public Configuration parse() {
    // parsed标志位 的处理
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    // 在 mybatis-config.xml配置文件 中查找 节点，并开始解析
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

  private void parseConfiguration(XNode root) {
    try {
      // 根据 root.evalNode("properties") 中的值就可以知道具体是解析哪个标签的方法咯
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(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"));
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

Mybatis 中的标签很多，所以相对应的解析方法也很多，这里挑几个比较重要的标签进行分析。

解析标签

 private void typeHandlerElement(XNode parent) throws Exception {
    if (parent != null) {
      // 处理  下的所有子标签
      for (XNode child : parent.getChildren()) {
        // 处理  标签
        if ("package".equals(child.getName())) {
          // 获取指定的包名
          String typeHandlerPackage = child.getStringAttribute("name");
          // 通过 typeHandlerRegistry 的 register(packageName)方法
          // 扫描指定包中的所有 TypeHandler类，并进行注册
          typeHandlerRegistry.register(typeHandlerPackage);
        } else {
          // Java数据类型
          String javaTypeName = child.getStringAttribute("javaType");
          // JDBC数据类型
          String jdbcTypeName = child.getStringAttribute("jdbcType");
          String handlerTypeName = child.getStringAttribute("handler");
          Class javaTypeClass = resolveClass(javaTypeName);
          JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
          Class typeHandlerClass = resolveClass(handlerTypeName);
          // 注册
          if (javaTypeClass != null) {
            if (jdbcType == null) {
              typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
            } else {
              typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
            }
          } else {
            typeHandlerRegistry.register(typeHandlerClass);
          }
        }
      }
    }
  }

解析标签

/**
   * Mybatis 可以配置多个 环境，分别用于开发、测试及生产等，
   * 但每个 SqlSessionFactory实例 只能选择其一
   */
  private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
      // 如果未指定 XMLConfigBuilder 的 environment字段，则使用 default属性 指定的 环境
      if (environment == null) {
        environment = context.getStringAttribute("default");
      }
      // 遍历 节点
      for (XNode child : context.getChildren()) {
        String id = child.getStringAttribute("id");
        if (isSpecifiedEnvironment(id)) {
          // 实例化 TransactionFactory
          TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
          // 创建 DataSourceFactory 和 DataSource
          DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
          DataSource dataSource = dsFactory.getDataSource();
          // 创建的 Environment对象 中封装了上面的 TransactionFactory对象 和 DataSource对象
          Environment.Builder environmentBuilder = new Environment.Builder(id)
              .transactionFactory(txFactory)
              .dataSource(dataSource);
          // 为 configuration 注入 environment属性值
          configuration.setEnvironment(environmentBuilder.build());
        }
      }
    }
  }

解析标签

Mybatis 不像 Hibernate 那样，通过 HQL 的方式直接帮助开发人员屏蔽不同数据库产品在 sql 语法 上的差异，针对不同的数据库产品， Mybatis 往往要编写不同的 sql 语句。但在 mybatis-config.xml 配置文件 中，可以通过 定义所有支持的数据库产品的 databaseId，然后在映射配置文件中定义 sql 语句节点 时，通过 databaseId 指定该 sql 语句 应用的数据库产品，也可以达到类似的屏蔽数据库产品的功能。Mybatis 初始化时，会根据前面解析到的 DataSource 来确认当前使用的数据库产品，然后在解析映射文件时，加载不带 databaseId 属性 的 sql 语句 及带有 databaseId 属性 的 sql 语句，其中，带有 databaseId 属性 的 sql 语句 优先级更高，会被优先选中。

 /**
   * 解析 节点，并创建指定的 DatabaseIdProvider对象，
   * 该对象会返回 databaseId的值，Mybatis 会根据 databaseId 选择对应的 sql语句 去执行
   */
  private void databaseIdProviderElement(XNode context) throws Exception {
    DatabaseIdProvider databaseIdProvider = null;
    if (context != null) {
      String type = context.getStringAttribute("type");
      // 为了保证兼容性，修改 type取值
      if ("VENDOR".equals(type)) {
          type = "DB_VENDOR";
      }
      // 解析相关配置信息
      Properties properties = context.getChildrenAsProperties();
      // 创建 DatabaseIdProvider对象
      databaseIdProvider = (DatabaseIdProvider) resolveClass(type).newInstance();
      // 配置 DatabaseIdProvider，完成初始化
      databaseIdProvider.setProperties(properties);
    }
    Environment environment = configuration.getEnvironment();
    if (environment != null && databaseIdProvider != null) {
      // 根据前面解析到的 DataSource 获取 databaseId，并记录到 configuration 的 configuration属性 上
      String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
      configuration.setDatabaseId(databaseId);
    }
  }

Mybatis 提供了 DatabaseIdProvider 接口，该接口的核心方法为 getDatabaseId(DataSource dataSource)，主要根据 dataSource 查找对应的 databaseId 并返回。该接口的主要实现类为 VendorDatabaseIdProvider。

public class VendorDatabaseIdProvider implements DatabaseIdProvider {

  private static final Log log = LogFactory.getLog(VendorDatabaseIdProvider.class);

  private Properties properties;

  @Override
  public void setProperties(Properties p) {
    this.properties = p;
  }

  @Override
  public String getDatabaseId(DataSource dataSource) {
    if (dataSource == null) {
      throw new NullPointerException("dataSource cannot be null");
    }
    try {
      return getDatabaseName(dataSource);
    } catch (Exception e) {
      log.error("Could not get a databaseId from dataSource", e);
    }
    return null;
  }

  private String getDatabaseName(DataSource dataSource) throws SQLException {
    // 解析到数据库产品名
    String productName = getDatabaseProductName(dataSource);
    if (this.properties != null) {
      // 根据 子节点 配置的数据库产品和 databaseId 之间的对应关系，
      // 确定最终使用的 databaseId
      for (Map.Entry property : properties.entrySet()) {
        if (productName.contains((String) property.getKey())) {
          return (String) property.getValue();
        }
      }
      // 没有合适的 databaseId，则返回 null
      return null;
    }
    return productName;
  }

  // 根据 dataSource 获取 数据库产品名的具体实现
  private String getDatabaseProductName(DataSource dataSource) throws SQLException {
    Connection con = null;
    try {
      con = dataSource.getConnection();
      DatabaseMetaData metaData = con.getMetaData();
      return metaData.getDatabaseProductName();
    } finally {
      if (con != null) {
        try {
          con.close();
        } catch (SQLException e) {
          // ignored
        }
      }
    }
  }
}

解析标签

Mybatis 初始化时，除了加载 mybatis-config.xml 文件，还会加载全部的映射配置文件，mybatis-config.xml 文件的 节点 会告诉 Mybatis 去哪里查找映射配置文件，及使用了配置注解标识的接口。

/**
   * 解析 节点，本方法会创建 XMLMapperBuilder对象 加载映射文件，如果映射配置文件存在
   * 相应的 Mapper接口，也会加载相应的 Mapper接口，解析其中的注解 并完成向 MapperRegistry 的注册
   */
  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");
          // 扫描指定的包目录，然后向 MapperRegistry 注册 Mapper接口
          configuration.addMappers(mapperPackage);
        } else {
          // 获取 节点 的 resource、url、mapperClass属性，这三个属性互斥，只能有一个不为空
          // Mybatis 提供了通过包名、映射文件路径、类全名、URL 四种方式引入映射器。
          // 映射器由一个接口和一个 XML配置文件 组成，XML文件 中定义了一个 命名空间namespace，
          // 它的值就是接口对应的全路径。
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          // 如果 节点 指定了 resource 或是 url属性，则创建 XMLMapperBuilder对象 解析
          // resource 或是 url属性 指定的 Mapper配置文件
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            InputStream inputStream = Resources.getUrlAsStream(url);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
            mapperParser.parse();
          } else if (resource == null && url == null && mapperClass != null) {
            // 如果 节点 指定了 class属性，则向 MapperRegistry 注册 该Mapper接口
            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.");
          }
        }
      }
    }
  }

XMLMapperBuilder

和 XMLConfigBuilder 一样，XMLMapperBuilder 也继承了 BaseBuilder，其主要负责解析映射配置文件，其解析配置文件的入口方法也是 parse()，另外，XMLMapperBuilder 也将各个节点的解析过程拆分成了一个个小方法，然后由 configurationElement()方法 统一调用

public class XMLMapperBuilder extends BaseBuilder {
  public void parse() {
    // 是否已经加载过该配置文件
    if (!configuration.isResourceLoaded(resource)) {
      // 解析 节点
      configurationElement(parser.evalNode("/mapper"));
      // 将 resource 添加到 configuration 的 loadedResources属性 中，
      // 该属性是一个 HashSet类型的集合，其中记录了已经加载过的映射文件
      configuration.addLoadedResource(resource);
      // 注册 Mapper接口
      bindMapperForNamespace();
    }
    // 处理 configurationElement()方法 中解析失败的 节点
    parsePendingResultMaps();
    // 处理 configurationElement()方法 中解析失败的 节点
    parsePendingCacheRefs();
    // 处理 configurationElement()方法 中解析失败的 节点
    parsePendingStatements();
  }

  private void configurationElement(XNode context) {
    try {
      // 获取 节点 的 namespace属性
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      // 使用 MapperBuilderAssistant对象 的 currentNamespace属性 记录 namespace命名空间
      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"));
      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);
    }
  }
}

XMLMapperBuilder 也根据配置文件进行了一系列节点解析，我们着重分析一下比较重要且常见的 节点 和 节点

解析节点

select 语句 查询得到的结果是一张二维表，水平方向上是一个个字段，垂直方向上是一条条记录。而 Java 是面向对象的程序设计语言，对象是根据类的定义创建的，类之间的引用关系可以认为是嵌套结构。JDBC 编程 中，为了将结果集中的数据映射成 VO 对象，我们需要自己写代码从结果集中获取数据，然后将数据封装成对应的 VO 对象，并设置好对象之间的关系，这种 ORM 的过程中存在大量重复的代码。

Mybatis 通过 节点 定义了 ORM 规则，可以满足大部分的映射需求，减少重复代码，提高开发效率。

在分析 节点 的解析过程之前，先看一下该过程使用的数据结构。每个 ResultMapping 对象 记录了结果集中的一列与 JavaBean 中一个属性之间的映射关系。节点 下除了 子节点 的其它子节点，都会被解析成对应的 ResultMapping 对象。

public class ResultMapping {

  private Configuration configuration;
  // 对应节点的 property属性，表示 该列进行映射的属性
  private String property;
  // 对应节点的 column属性，表示 从数据库中得到的列名或列名的别名
  private String column;
  // 表示 一个 JavaBean 的完全限定名，或一个类型别名
  private Class javaType;
  // 进行映射列的 JDBC类型
  private JdbcType jdbcType;
  // 类型处理器
  private TypeHandler typeHandler;
  // 该属性通过 id 引用了另一个 节点，它负责将结果集中的一部分列映射成
  // 它所关联的结果对象。这样我们就可以通过 join方式 进行关联查询，然后直接映射成
  // 多个对象，并同时设置这些对象之间的组合关系(nested嵌套的)
  private String nestedResultMapId;
  // 该属性通过 id 引用了另一个 节点，它会把指定的列值传入 select属性 指定的
  // select语句 中作为参数进行查询。使用该属性可能会导致 ORM 中的 N+1问题，请谨慎使用
  private String nestedQueryId;
  private Set notNullColumns;
  private String columnPrefix;
  // 处理后的标志，共有两个：id 和 constructor
  private List flags;
  private List composites;
  private String resultSet;
  private String foreignColumn;
  // 是否延迟加载
  private boolean lazy;
} 
  
另一个比较重要的类是 ResultMap，每个 节点 都会被解析成一个 ResultMap 对象，其中每个节点所定义的映射关系，则使用 ResultMapping 对象 表示。
 
  
public class ResultMap {
  private Configuration configuration;

  // 这些属性一一对应了  中的属性
  private String id;
  private Class type;
  // 记录了除 节点 之外的其它映射关系(即，ResultMapping对象集合)
  private List resultMappings;
  // 记录了映射关系中带有 ID标志 的映射关系，如：节点 和 节点 的 子节点
  private List idResultMappings;
  // 记录了映射关系中带有 Constructor标志 的映射关系，如：所有子元素
  private List constructorResultMappings;
  // 记录了映射关系中不带有 Constructor标志 的映射关系
  private List propertyResultMappings;
  // 记录了所有映射关系中涉及的 column属性 的集合
  private Set mappedColumns;
  // 记录了所有映射关系中涉及的 property属性 的集合
  private Set mappedProperties;
  // 鉴别器，对应 节点
  private Discriminator discriminator;
  // 是否含有嵌套的结果映射，如果某个映射关系中存在 resultMap属性，
  // 且不存在 resultSet属性，则为true
  private boolean hasNestedResultMaps;
  // 是否含有嵌套查询，如果某个属性映射存在 select属性，则为true
  private boolean hasNestedQueries;
  // 是否开启自动映射
  private Boolean autoMapping;
}
 
  
了解了 ResultMapping 和 ResultMap 记录的信息之后，下面开始介绍 节点 的解析过程。在 XMLMapperBuilder 中通过 resultMapElements()方法 解析映射配置文件中的全部 节点，该方法会循环调用 resultMapElement()方法 处理每个  节点。
 
  
 private ResultMap resultMapElement(XNode resultMapNode) throws Exception {
    return resultMapElement(resultMapNode, Collections. emptyList());
  }

  private ResultMap resultMapElement(XNode resultMapNode, List additionalResultMappings) throws Exception {
    ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
    //  的 id属性，默认值会拼装所有父节点的 id 或 value 或 property属性值
    String id = resultMapNode.getStringAttribute("id",
        resultMapNode.getValueBasedIdentifier());
    //  的 type属性，表示结果集将被映射成 type 指定类型的对象
    String type = resultMapNode.getStringAttribute("type",
        resultMapNode.getStringAttribute("ofType",
            resultMapNode.getStringAttribute("resultType",
                resultMapNode.getStringAttribute("javaType"))));
    // 该属性指定了该 节点 的继承关系
    String extend = resultMapNode.getStringAttribute("extends");
    // 为 true 则启动自动映射功能，该功能会自动查找与列明相同的属性名，并调用 setter方法，
    // 为 false，则需要在 节点 内注明映射关系才会调用对应的 setter方法
    Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
    // 解析 type类型
    Class typeClass = resolveClass(type);
    Discriminator discriminator = null;
    // 该集合用来记录解析结果
    List resultMappings = new ArrayList();
    resultMappings.addAll(additionalResultMappings);
    // 获取并处理  的子节点
    List resultChildren = resultMapNode.getChildren();
    // child 单数形式，children 复数形式
    for (XNode resultChild : resultChildren) {
      // 处理 节点
      if ("constructor".equals(resultChild.getName())) {
        processConstructorElement(resultChild, typeClass, resultMappings);
      // 处理 节点
      } else if ("discriminator".equals(resultChild.getName())) {
        discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
      } else {
        // 处理 , , ,  等节点
        List flags = new ArrayList();
        if ("id".equals(resultChild.getName())) {
          flags.add(ResultFlag.ID);
        }
        // 创建 ResultMapping对象，并添加到 resultMappings集合
        resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
      }
    }
    ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
    try {
      return resultMapResolver.resolve();
    } catch (IncompleteElementException  e) {
      configuration.addIncompleteResultMap(resultMapResolver);
      throw e;
    }
  }
 
  
Mybatis 从 节点 获取到 id 属性 和 type 属性值 之后，就会通过 XMLMapperBuilder 的 buildResultMappingFromContext()方法 为 节点 创建对应的 ResultMapping 对象
 
  
/**
   * 根据上下文环境构建 ResultMapping
   */
  private ResultMapping buildResultMappingFromContext(XNode context, Class resultType, List flags) throws Exception {
    // 获取各个节点的属性，见文知意
    String property;
    if (flags.contains(ResultFlag.CONSTRUCTOR)) {
      property = context.getStringAttribute("name");
    } else {
      property = context.getStringAttribute("property");
    }
    String column = context.getStringAttribute("column");
    String javaType = context.getStringAttribute("javaType");
    String jdbcType = context.getStringAttribute("jdbcType");
    String nestedSelect = context.getStringAttribute("select");
    String nestedResultMap = context.getStringAttribute("resultMap",
        processNestedResultMappings(context, Collections. emptyList()));
    String notNullColumn = context.getStringAttribute("notNullColumn");
    String columnPrefix = context.getStringAttribute("columnPrefix");
    String typeHandler = context.getStringAttribute("typeHandler");
    String resultSet = context.getStringAttribute("resultSet");
    String foreignColumn = context.getStringAttribute("foreignColumn");
    boolean lazy = "lazy".equals(context.getStringAttribute("fetchType", configuration.isLazyLoadingEnabled() ? "lazy" : "eager"));
    Class javaTypeClass = resolveClass(javaType);
    @SuppressWarnings("unchecked")
    Class> typeHandlerClass = (Class>) resolveClass(typeHandler);
    JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
    // 创建 ResultMapping对象 并返回
    return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy);
  }
 
  
得到 ResultMapping 对象集合 之后，会调用 ResultMapResolver 的 resolve()方法，该方法会调用 MapperBuilderAssistant 的 addResultMap()方法 创建 ResultMap 对象，并将 ResultMap 对象 添加到 Configuration 的 resultMaps 集合 中保存。
 
  
public class MapperBuilderAssistant extends BaseBuilder {
  public ResultMap addResultMap(String id, Class type, String extend,
      Discriminator discriminator, List resultMappings, Boolean autoMapping) {
    // ResultMap 的 完整id 是 "namespace.id" 的格式
    id = applyCurrentNamespace(id, false);
    // 获取 父ResultMap 的 完整id
    extend = applyCurrentNamespace(extend, true);

    // 针对 extend属性 进行的处理
    if (extend != null) {
      if (!configuration.hasResultMap(extend)) {
        throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
      }
      // 父ResultMap对象
      ResultMap resultMap = configuration.getResultMap(extend);
      // 父ResultMap对象 的 ResultMapping集合
      List extendedResultMappings = new ArrayList(resultMap.getResultMappings());
      // 删除需要覆盖的 ResultMapping集合
      extendedResultMappings.removeAll(resultMappings);
      // Remove parent constructor if this resultMap declares a constructor.
      boolean declaresConstructor = false;
      for (ResultMapping resultMapping : resultMappings) {
        if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
          declaresConstructor = true;
          break;
        }
      }
      if (declaresConstructor) {
        Iterator extendedResultMappingsIter = extendedResultMappings.iterator();
        while (extendedResultMappingsIter.hasNext()) {
          if (extendedResultMappingsIter.next().getFlags().contains(ResultFlag.CONSTRUCTOR)) {
            extendedResultMappingsIter.remove();
          }
        }
      }
      // 添加需要被继承下来的 ResultMapping集合
      resultMappings.addAll(extendedResultMappings);
    }
    ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
        .discriminator(discriminator)
        .build();
    configuration.addResultMap(resultMap);
    return resultMap;
  }
}
 
  
解析节点
 
  
在映射配置文件中，可以使用 节点 定义可重用的 SQL 语句片段，当需要重用 节点 中定义的 SQL 语句片段 时，只需要使用 节点 引入相应的片段即可，这样，在编写 SQL 语句 以及维护这些 SQL 语句 时，都会比较方便。XMLMapperBuilder 的 sqlElement()方法 负责解析映射配置文件中定义的 全部节点。
 
  
private void sqlElement(List list) throws Exception {
    if (configuration.getDatabaseId() != null) {
      sqlElement(list, configuration.getDatabaseId());
    }
    sqlElement(list, null);
  }

  private void sqlElement(List list, String requiredDatabaseId) throws Exception {
    // 遍历 节点
    for (XNode context : list) {
      String databaseId = context.getStringAttribute("databaseId");
      String id = context.getStringAttribute("id");
      // 为 id 添加命名空间
      id = builderAssistant.applyCurrentNamespace(id, false);
      // 检测  的 databaseId 与当前 Configuration 中记录的 databaseId 是否一致
      if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
        // 记录到 sqlFragments(Map) 中保存
        sqlFragments.put(id, context);
      }
    }
  }
 
  
XMLStatementBuilder
 
  
绑定 Mapper 接口
 
  
通过之前对 binding 模块 的解析可知，每个映射配置文件的命名空间可以绑定一个 Mapper 接口，并注册到 MapperRegistry 中。XMLMapperBuilder 的 bindMapperForNamespace()方法 中，完成了映射配置文件与对应 Mapper 接口 的绑定。
 
  
public class XMLMapperBuilder extends BaseBuilder {
  private void bindMapperForNamespace() {
    // 获取映射配置文件的命名空间
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
      Class boundType = null;
      try {
        // 解析命名空间对应的类型
        boundType = Resources.classForName(namespace);
      } catch (ClassNotFoundException e) {
        //ignore, bound type is not required
      }
      if (boundType != null) {
        // 是否已加载 boundType接口
        if (!configuration.hasMapper(boundType)) {
          // 追加个 "namespace:" 的前缀，并添加到 Configuration 的 loadedResources集合 中
          configuration.addLoadedResource("namespace:" + namespace);
          // 添加到 Configuration的mapperRegistry集合 中，另外，往这个方法栈的更深处看 会发现
          // 其创建了 MapperAnnotationBuilder对象，并调用了该对象的 parse()方法 解析 Mapper接口
          configuration.addMapper(boundType);
        }
      }
    }
  }
}

public class MapperRegistry {
  public  void addMapper(Class type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        knownMappers.put(type, new MapperProxyFactory(type));
        // 解析 Mapper接口 type 中的信息
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }
}

public class MapperAnnotationBuilder {
  public void parse() {
    String resource = type.toString();
    // 是否已经加载过该接口
    if (!configuration.isResourceLoaded(resource)) {
      // 检查是否加载过该接口对应的映射文件，如果未加载，则创建 XMLMapperBuilder对象
      // 解析对应的映射文件，该过程就是前面介绍的映射配置文件解析过程
      loadXmlResource();
      configuration.addLoadedResource(resource);
      assistant.setCurrentNamespace(type.getName());
      // 解析 @CacheNamespace注解
      parseCache();
      // 解析 @CacheNamespaceRef注解
      parseCacheRef();
      // type接口 的所有方法
      Method[] methods = type.getMethods();
      for (Method method : methods) {
        try {
          if (!method.isBridge()) {
            // 解析 SelectKey、ResultMap 等注解，并创建 MappedStatement对象
            parseStatement(method);
          }
        } catch (IncompleteElementException e) {
          // 如果解析过程出现 IncompleteElementException异常，可能是因为引用了
          // 未解析的注解，这里将出现异常的方法记录下来，后面提供补偿机制，重新进行解析
          configuration.addIncompleteMethod(new MethodResolver(this, method));
        }
      }
    }
    // 遍历 configuration 中的 incompleteMethods集合，集合中记录了未解析的方法
    // 重新调用这些方法进行解析
    parsePendingMethods();
  }
}
 
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(开源框架,java,mybatis,学习,程序人生)
        

            

                

                    
情绪觉察日记第37天
                        露露_e800

                        
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
                    
                    
机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
                    
                    
铭刻于星（四十二）
                        随风至

                        
69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
                    
                    
UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
                    
                    
学点心理知识，呵护孩子健康
                        静候花开_7090

                        
昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
                    
                    
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()，那么我们在接口
                    
                    
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
                    
                    
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
                    
                    
回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
                    
                    
Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
                    
                    
2019-12-22-22:30
                        涓涓1016

                        
今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
                    
                    
将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
                    
                    
四章-32-点要素的聚合
                        彩云飘过

                        
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
                    
                    
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分别代
                    
                    
GitHub上克隆项目
                        bigbig猩猩
github
                        
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
                    
                    
关于城市旅游的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：做与用户的交互行为文章目录前端学习路线
                    
                    
Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
                    
                    
人工智能时代，程序员如何保持核心竞争力？
                        jmoych
人工智能
                        
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
                    
                    
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的运行
                    
                    
阶段总结反思
                        轻争

                        
马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
                    
                    
ARM驱动学习之基础小知识
                        JT灬新一
ARM嵌入式arm开发学习
                        
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
                    
                    
ARM驱动学习之5 LEDS驱动
                        JT灬新一
嵌入式C底层arm开发学习单片机
                        
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
                    
                    
ARM驱动学习之4小结
                        JT灬新一
嵌入式C++arm开发学习linux
                        
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
                    
                    
展现思维导图魅力，不断挖掘人生宝藏
                        思维导图讲师Mandy

                        
第13期最强思维导图训练营已经结束一周了，但是我依旧是感觉所有学员还在努力的学习，这些学员中有教师、学生、白领、公务员、宝妈等等，只要你努力，只要你想改变自己，任何行业，任何岗位都可以参与进来，28天足以让你见成效，在这28天中，我们的学员不仅仅是收获了一枚毕业证，最重要的是让自己的思维方式得到升级，今天的你为自己投资，明天的你就会感谢你今天的付出，我们来听一听来自13期最强思维导图训练营优秀学员
                    
                    
2019-3-23晨间日记
                        红红火火小耳朵

                        
今天是什么日子起床：7点40就寝：23点半天气：有太阳，不过一会儿出来一会儿进去特别清爽的凉意，还蛮舒服的心情：小激动要给女朋友过生日啦纪念日：田田女士过生日任务清单昨日完成的任务，最重要的三件事：1.英语一对一2.运动计划3.认真护肤习惯养成：调整状态周目标·完成进度英语七天打卡（5/7）轻课阅读（87/180）音标课（25/30）读书（福尔摩斯一章）学习·信息·阅读#英语课#Cookingte
                    
                    
【华为OD技术面试真题精选 - 非技术题】 -HR面，综合面_华为od hr面
                        一个射手座的程序媛
程序员华为od面试职场和发展
                        
最后的话最近很多小伙伴找我要Linux学习资料，于是我翻箱倒柜，整理了一些优质资源，涵盖视频、电子书、PPT等共享给大家！资料预览给大家整理的视频资料：给大家整理的电子书资料：如果本文对你有帮助，欢迎点赞、收藏、转发给朋友，让我有持续创作的动力！网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以点击这里获
                    
                                
对于规范和实现，你会混淆吗？
                                    yangshangchuan
HotSpot
                                    
昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： 
 
 JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
                                
                                
android 网络
                                    百合不是茶
网络
                                    
android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat 
  
服务器代码;  servlet的使用需要在xml中注册 
package servlet;

import java.io.IOException;
import java.util.Arr
                                
                                
[读书笔记]读法拉第传
                                    comsci
读书笔记
                                    
 
 
      1831年的时候,一年可以赚到1000英镑的人..应该很少的... 
 
      要成为一个科学家,没有足够的资金支持,很多实验都无法完成 
 
      但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
                                
                                
随机数的产生
                                    沐刃青蛟
随机数
                                    
c++中阐述随机数的方法有两种： 
  
一是产生假随机数（不管操作多少次，所产生的数都不会改变） 
  
       这类随机数是使用了默认的种子值产生的，所以每次都是一样的。 
  
	//默认种子
	for (int i = 0; i < 5; i++)
	{
		cout<<
                                
                                
PHP检测函数所在的文件名
                                    IT独行者
PHP函数
                                    
很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。 
代码： 
     
[php]   
view plain 
copy    
 
 // Filename: functions.php    
 <?php&nbs
                                
                                
银行各系统功能简介
                                    文强chu
金融
                                    
银行各系统功能简介     　   业务系统   核心业务系统     业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等       清分清算系统     以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程       国际结算系
                                
                                
Python学习1(pip django 安装以及第一个project)
                                    小桔子
pythondjangopip
                                    
    最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！ 
第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 
第二部：解压这个压缩文件，会看到一个setup.p
                                
                                
php 数组
                                    aichenglong
PHP排序数组循环多维数组
                                    
1 php中的创建数组 
 $product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数 
2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 
 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 
 $numbers=range(1,10,
                                
                                
安装python2.7
                                    AILIKES
python
                                    
安装python2.7 
1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 
2、复制解压 
#mkdir -p /opt/usr/python 
#cp  /opt/soft/Python-2
                                
                                
java异常的处理探讨
                                    百合不是茶
JAVA异常
                                    
//java异常  
/* 
1，了解java 中的异常处理机制，有三种操作 
a,声明异常  
b,抛出异常  
c,捕获异常 
2，学会使用try-catch-finally来处理异常 
3，学会如何声明异常和抛出异常 
4，学会创建自己的异常 
  
*/ 
  
//2，学会使用try-catch-finally来处理异常 
  
                                
                                
getElementsByName实例
                                    bijian1013
element
                                    
实例1： 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/x
                                
                                
探索JUnit4扩展：Runner
                                    bijian1013
java单元测试JUnit
                                    
        参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。 
        文章地址：http://www.blogjava.net/jiangshachina/archive/20
                                
                                
[MongoDB学习笔记二]MongoDB副本集
                                    bit1129
mongodb
                                    
1. 副本集的特性 
  1)一台主服务器(Primary),多台从服务器(Secondary) 
  2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作 
  3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来 
  
2
                                
                                
【Spark八十一】Hive in the spark assembly
                                    bit1129
assembly
                                    
Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 
 
  1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
                                
                                
Nginx问题定位之监控进程异常退出
                                    ronin47

                                    
nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 
1. 在error.log中查看是否有signal项，如果有，看看signal是多少。 
比如，这是一个异常退出的情况： 
$grep signal error.log

2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
                                
                                
No grammar constraints (DTD or XML schema).....两种解决方法
                                    byalias
xml
                                    
方法一：常用方法   关闭XML验证 
工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。 
 
方法二：（个人推荐） 
添加 内容如下 
<?xml version=
                                
                                
Netty源码学习-DefaultChannelPipeline
                                    bylijinnan
netty
                                    
package com.ljn.channel;

/**
 * ChannelPipeline采用的是Intercepting Filter 模式
 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现
 * 
 * 下面对ChannelPipeline作一个模拟，只模拟关键代码：
 */
public class Pipeline {
 
                                
                                
MYSQL数据库常用备份及恢复语句
                                    chicony
mysql
                                    
  
备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 
mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件 
 
备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 
mysqldump -–add-drop-table -uusername -ppassword databasename > ba
                                
                                
小白谈谈云计算--基于Google三大论文
                                    CrazyMizzz
Google云计算GFS
                                    
    之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。 
    我先说说GFS 
  &n
                                
                                
hadoop 平衡空间设置方法
                                    daizj
hadoopbalancer
                                    
在hdfs-site.xml中增加设置balance的带宽，默认只有1M： 
<property> 
  <name>dfs.balance.bandwidthPerSec</name> 
    <value>10485760</value> 
    <description&g
                                
                                
Eclipse程序员要掌握的常用快捷键
                                    dcj3sjt126com
编程
                                    
   判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。   曾有人在豆瓣评
《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个
程序员图书列表，目的也就是通过读书，让程序员变懒。     程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
                                
                                
Android学习之路
                                    dcj3sjt126com
Android学习
                                    
转自：http://blog.csdn.net/ryantang03/article/details/6901459 
以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。 
下面说说我学习Android的感受，我学Android首先是看MARS的视
                                
                                
java 遍历Map的四种方法
                                    eksliang
javaHashMapjava 遍历Map的四种方法
                                    
转载请出自出处： 
http://eksliang.iteye.com/blog/2059996 
 
package com.ickes;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
/**
 * 遍历Map的四种方式

                                
                                
【精典】数据库相关相关
                                    gengzg
数据库
                                    
package C3P0; 
import java.sql.Connection; 
import java.sql.SQLException; 
import java.beans.PropertyVetoException; 
import com.mchange.v2.c3p0.ComboPooledDataSource; 
public class DBPool{       
                                
                                
自动补全
                                    huyana_town
自动补全
                                    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
                                
                                
jquery在线预览PDF文件，打开PDF文件
                                    天梯梦
jquery
                                    
最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。 
  
核心代码 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
                                
                                
ViewPager刷新单个页面的方法
                                    lovelease
androidviewpagertag刷新
                                    
  使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
                                
                                
利用按位取反（~）从复合枚举值里清除枚举值
                                    草料场
enum
                                    
以 C# 中的 System.Drawing.FontStyle 为例。  
  
如果需要同时有多种效果， 
如：“粗体”和“下划线”的效果，可以用按位或（|） 
FontStyle style = FontStyle.Bold | FontStyle.Underline; 
  
如果需要去除 style 里的某一种效果， 
                                
                                
Linux系统新手学习的11点建议
                                    刘星宇
编程工作linux脚本
                                    
　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。 
 
　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
                                
                                
hibernate dao层应用之HibernateDaoSupport二次封装
                                    wangzhezichuan
DAOHibernate
                                    
/** 
 * <p>方法描述:sql语句查询 返回List<Class> </p> 
 * <p>方法备注: Class 只能是自定义类 </p> 
 * @param calzz 
 * @param sql 
 * @return 
 * <p>创建人：王川</p> 
 * <p>创建时间：Jul
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

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