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,学习,程序人生)



java数组拷贝的方法
千锋IT教育
javajava数组
小千在给大家讲解数组扩容时，涉及到了数组中数据元素的拷贝复制。那么除了上面的拷贝方式之外，数组还有哪些拷贝方式呢？1.拷贝方式在Java中，数组的拷贝主要有三种实现方式：1.通过循环语句，将原数组中的各个元素拷贝到新数组中(即数组扩容案例中使用的方法)；2.System类提供的数组拷贝方法；3.Arrays类提供的数组拷贝方法。接下来小千就设计几个案例，来给大家展示这几种方式都是怎么进行数组拷贝的

读书随笔25
木木_cd40
【我在悦读】-木木【书名】:《跃迁》【作者】:古典【篇目】:第四章“破局思维”前部分【收获】001高手并不是能力比我们强、智商比我们高、定力比我们好，只是因为他们思考比我们深、见识比我们广，他们看到了更大的系统。(本章的关注点在于系统学习的重要性，以及如何正确看待系统科学在我们日常生活中的应用。掌握正确的破局思维，就是学会系统性的思考问题。)002一个系统至少包含三个因素：元素、元素之间的关系，以

Vue组件学习
yancolin
Vue的精华之处就在于它的组件，重复使用，节省代码，提升工作效率。Vue组件要使用先要注册，注册分为全局的和局部的注册。全局注册：注：1.my-component就是注册的组件自定义标签名称;2.template的DOM结构必须被一个元素包含，如果直接写成'全局组件'，不带""是无法渲染的。Vue.component('my-component',{template:'全局组件';});varap

2022-12-26
向日葵的执着
每日一省（第279篇）孩子元月5号就要期末考试了。这几天辅导他写作业的过程中，发现有很多知识都掌握的不牢固，于是我难免就有些写着急了。我的态度和语气都写满了焦虑和紧张不安，孩子也被训的不知所措。今天晚上吃过饭后，我们又开始了复习，面对孩子惨兮兮的学习效果，压抑了几天的不满情绪瞬间爆发，一阵狂风暴雨之后，我发现孩子看我的眼神变了（他的眼中充满了愤怒和恐惧），跟我说话的语气也不一样了（充满了不屑和无奈

在家学习的第73天—日更20天
九肙
大家好，我是九肙，今天是我在家学习的第73天。来自网友在连续更文20天，昨天成功获得日更20日徽章。对自己来说，是一份极大的鼓励。因为自己在写作上不是天赋型的选手，加上自己情感不丰富不细腻，写的文章自己都很干。一直想让自己能够写打动人的东西，一直在受挫和爬起来中努力前行。看到上很多人发的优秀文章，看到她说自己运营公众号的心得，自己很是羡慕。大二就想运营公众号一直到现在都没有开始。下周，我决定开始运

全能第三方支付对接pay-java-parent 2.12.7 发布,支付聚合
egzosn
支付第三方支付支付聚合支付对接支付pay微信
全能第三方支付对接Java开发工具包.优雅的轻量级支付模块集成支付对接支付整合（微信,支付宝,银联,友店,富友,跨境支付paypal,payoneer(P卡派安盈)易极付）app,扫码,网页支付刷卡付条码付刷脸付转账服务商模式、支持多种支付类型多支付账户，支付与业务完全剥离，简单几行代码即可实现支付，简单快速完成支付模块的开发，可轻松嵌入到任何系统里目前仅是一个开发工具包（即SDK），只提供简单W

2020-09-08 开学，从构建相互倾听的关系开始
橙橙妈妈_712e
开学伊始任教两个年级，最大的感受是六年级的课堂沉闷；二年级的课堂乱哄哄。呈现出两种极端，怎么办？昨天晚上听了关于构建学习共同体的一个讲座，受益匪浅。学习共同体致力于构建宁静、润泽、共同成长的课堂，能够有效解决目前课堂上学优生霸占课堂，其他学生学习兴趣低下，陷入恶性循环，逐渐沦为学困生的问题等。构建互相倾听的关系是构建学习共同体的开端。首先教师要做出倾听的表率，不仅要从肢体语言上表现出教师在认真听他

使用最大边际相关性(MMR)选择示例：提高AI模型的多样性和相关性
aehrutktrjk
人工智能easyui前端python
使用最大边际相关性(MMR)选择示例：提高AI模型的多样性和相关性引言在机器学习和自然语言处理领域，选择合适的训练示例对模型性能至关重要。最大边际相关性(MaximalMarginalRelevance,MMR)是一种优秀的示例选择方法，它不仅考虑了示例与输入的相关性，还注重保持所选示例之间的多样性。本文将深入探讨如何使用MMR来选择示例，以提高AI模型的性能和泛化能力。什么是最大边际相关性(MM

缘分真奇妙
学霸角
昨天参观了朋友的四层别墅和院子，每一处都是男女主任精致用心，从餐饮到桌布到鲜花到小礼品，事事周到，真是有一种特别美好的体验，男主人的温文尔雅，女主人的热情好客，总是让你从尴尬到恰是完美过度，饭后男主人回书房工作，朋友陪我从地下室到天台参观，给我讲解选材的细节和装饰的一些经验，她真的很像学习过家居设计的专业人士，许多技巧在里面……意犹未尽，她开车送出我近一半的路程，依依不舍，我们相约孩子放假再一起玩

LangChain集成指南:如何利用多样化的AI提供商
aehrutktrjk
人工智能langchainpython
LangChain集成指南:如何利用多样化的AI提供商引言在人工智能和机器学习领域,LangChain已成为一个强大而灵活的框架,允许开发者轻松集成各种AI服务提供商。本文将深入探讨LangChain的集成能力,介绍如何利用不同的AI提供商来增强你的应用程序,并提供实用的代码示例。LangChain集成概览LangChain支持多种AI提供商的集成,这些集成可以分为两类:独立包集成:这些提供商有独

高山由沙砾堆积而成，成功从点滴小事积累做起
584916575978
当今住世佛陀《世法哲言》教言：“大德之成，微德累至，公路之长点面沙石之汇，如欲成德弗忽小品之行。”我对这段法语的理解是，生活中我们遇到的那些品德高尚学识广博的人，都是要经历多年学习问道，不忽略细微小德的一点点日积月累，才慢慢成为某个领域的高人、专家。世上绝不会有所谓的横空出世就已经是一代大德、名人典范的。这令我想起“第七个饼”的故事。故事大意说，从前有一位穷苦的砍柴人每天靠卖柴为生，辛苦一天下来卖

感恩日记-2
我是利芳
看了伙伴们的感恩日记，心里暖暖的。不同的视角，丰富的感受，或优美或朴实的文字，深深地打动了我。感恩遇见，让自己和大家一起成长！首先感恩我自己，手术后认真吃饭，努力康复，好好休息，保持乐观，坚持学习和成长，让自己尽快恢复健康。感恩朋友楼姐寄来的微电脑智电热水壶，让我方便喝水。同时也体会到现代科技带给我们的便利。感恩姐姐对我的包容，我的不耐烦，我的情绪，我对她有时语言犀利，她都对我和颜悦色，让我看到自

【免费】springboot项目申报管理系统|毕业设计|Javaweb项目
计算机学姐来啦
springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的

随意养生0831
苏梅LI
今天和邵老师，了妈一起共修太极。今天在定步云手和活步云手时，都关注两个方面的问题，第一是沉肩坠肘，第二是松胯。因为有需要观察的地方，所以思绪并不纷飞。今天聊起学习中医的问题，我还是对最初的经络比较感兴趣。最近曾学了一遍，12条经脉的易堵穴位。但是邵老师说了一句非常到位的话，她认为经络是否通畅，最关键还要看自身的能量。这个能量既来自于五谷精微之气，也来自于天地之间，还来自于大德的修炼。下午茶时间，改

超级无敌详细的Mysql数据库笔记（基础篇版）
当大哥爱上学习
mysql数据库笔记
注：本篇笔记根据黑马程序员MySQL数据库入门到精通的内容所创建，适合复习和结合该视频学习使用。一.基础1.关系型数据库(RDBMS)概念:建立在关系模型基础上，由多张相互连接的二维表组成的数据库。特点:使用表存储数据，格式统一，便于维护使用SQL语言操作，标准统一，使用方便。2.SQLSQL通用语法SQL语句可以单行或多行书写，以分号结尾.SQL语句可以使用空格/缩进来增强语句的可读性。MySQ

11.学无止境
萌柳青青
人生就像是坐过山车，跌跌宕宕，起起伏伏。有时候，心情平静如水；有时候，如坚石拍打浪花！好好学习天天向上这是一场经历，也是一个过程。生活如此，学习亦是如此！在不断地试错中，终于找到适合自己的学习方法及有效资源。突然发现，当你一旦决定开始做一件事并付诸于行动时，你会发现，原以为的一切问题都不是问题。忘了有多久，没有这样的一个学习冲劲了。我享受着争分夺秒与时间赛跑的日子，我享受着这种全身心投入学习的感觉

MyBatis系统学习（一）——项目结构及其含义
OEC小胖胖
MyBatismybatis学习web后端
1.MyBatis简介MyBatis是一款优秀的持久层框架，它通过SQL映射的方式实现Java对数据库操作的映射，既保留了SQL语句的灵活性，也简化了代码的编写。在一个MyBatis项目中，核心部分主要有：配置文件（mybatis-config.xml）映射文件（Mapper.xml）实体类（Entity/POJO）接口类（Mapper接口）MyBatis会话工厂（SqlSessionFactor

【开发环境搭建】Macbook M1搭建Java开发环境
weixin_44329069
java开发语言
JDK安装与配置下载并安装JDK：ARM64DMG安装包下载链接：JDK21forMac(ARM64)。双击下载的DMG文件，按照提示安装JDK。配置环境变量：打开终端，使用vim编辑.bash_profile文件：vim~/.bash_profile在文件中添加以下内容来设置JAVA_HOME：exportJAVA_HOME=/Library/Java/JavaVirtualMachines/j

Java中四种常用的数组复制的方法copyOf(),arraycop()，clone（）和copyOfRange()的使用与区别
方九九
java知识点总结java
所谓复制数组，是指将一个数组中的元素在另一个数组中进行复制。本文主要介绍关于Java里面的数组复制（拷贝）的几种方式和用法。在Java中实现数组复制分别有以下4种方法：1.Arrays类的copyOf()方法2.Arrays类的copyOfRange()方法3.System类的arraycopy()方法4.Object类的clone()方法下面来详细介绍这4种方法的使用。使用copyOf()方法和

不要再学习巴菲特和马云了
李影_8de2
很多时候，我们普通人我感觉学习的榜样对标错了。我们往往对标的是这个社会上谁是最优秀的，数一数二的那些人，潜意识里就觉得他有一个大招，学会了他这一个大招就能够世界第一。炒股言必称巴菲特，做电商言必称马云。是的，他们取得至高的成就这一点无可置疑，但是我们普通人真的应该学习他们吗？学习顶尖的人对我们来讲是最好的途径吗？我看未必。有一句话说，一屋不扫何以扫天下？很多时候我们太多的时候关注到名人身上那些带着

探索未来，大规模分布式深度强化学习——深入解析IMPALA架构
汤萌妮Margaret
探索未来，大规模分布式深度强化学习——深入解析IMPALA架构scalable_agent项目地址:https://gitcode.com/gh_mirrors/sc/scalable_agent在当今的人工智能研究前沿，深度强化学习（DRL）因其在复杂任务中的卓越表现而备受瞩目。本文要介绍的是一个开源于GitHub的重量级项目：“ScalableDistributedDeep-RLwithImp

云服务业界动态简报-20180128
Captain7
一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI

在职四战考研3day
MM加油女孩
今日已完成考研任务：与教务处老师联系，学习怎么正确使用书籍；看333教育综合大纲；日总结：下午下班后与教务处老师联系，老师跟我讲了资料的正确使用方式，心里也有了大概的思路——根据老师提供的教材，我第一轮需要用到的资料就是一本通+网课，书籍只作为辅助对象，倘若网课里的内容听懂了，老师说书籍就可以不看了。第二轮复习：就是网课+自己构建思维导图，并尝试做333教育综合的主观题；第三轮复习：背诵客观题起码

每日听书：《论语·学而》（四）
米妮妈妈爱读书
【原文】1.子夏曰：“贤贤易色；事父母，能竭其力；事君，能致其身；与朋友交，言而有信。虽曰未学，吾必谓之学矣。”2.子曰：“君子不重则不威，学则不固。主忠信。无友不如己者；过，则勿惮改。”【译文】1.子夏说：“一个人能够关注内在的好的东西，用对内在的关注替换对外在的执着；侍奉父母，能够竭尽全力；服侍君主，能够不遗余力；同朋友交往，说话诚实恪守信用。这样的人，尽管他自己说没有学习过，我一定说他已经学

《C++语言的设计和演化》读书感悟（一）
依晴无旧
C\C++java开发语言
写了一百多篇技术文章了，我突然想写一下和技术文搭一点关系的语言发展设计的文章，《C++语言的设计和演化》是我无聊翻自己库存电子书找到了，因为当年看这本书是C++之父写的，所以就保存下来，但是当时主要学习C++，这本书更多是C++之父从本身出发，对C++设计和演化的观点和感想，所以当时就被我扔去吃灰了。现在重拾起来，读起来别有风味。开发语言，虽然很多，但是万变不离其宗，学进去了，无非就是数据类型、控

艾顺平《谈谈对“后进生”的工作》读后感
e3adebe97f63
“后进生”顾名思义就是“学困生”。这是大多数教师拿着头疼的问题。教了17年书的我，也没找到什么有效的方法。今天读了苏霍姆林斯基的《谈谈对后进生的工作》之后，我在大脑中有了一个轮廓。特别是他后一段话谈到的，请记住：“儿童的学习越困难，他在学习中遇到的似乎无法克服的障碍越多，他就应当更多地阅读。阅读能交给他思考，而思考会变成一种激发智力的刺激。书籍和由书籍激发起来的活的思想，是防止死记硬背的最强有力的

2021-08-26
shali
8.26-159今天是开学前学校组织的培训会议，因为大多是其他学科中考阅卷经验交流和班主任的班级管理交流，说实话真是听不进去，感觉与自己没大有关系，所以求知欲不是很强。会后分管校长找到我，跟我交流一下这学期的工作。第一，新换的校长对我们的课间操提出了较高的要求，要学习一套健身操来代替广播体操，进行课间操锻炼。并且因为七年级今年教体局要求不进行军训了，学习健身操要提上日程，开学后即可进行健身操的学习

学单片机怎么在3-5个月内找到工作？
无际单片机编程
单片机嵌入式开发物联网stm32c语言
每个初学者，都如履薄冰，10几年前，我自学单片机时，也一样。想通过学习，找一份体面点的工作，又害怕辛辛苦苦学出来，找不到工作。好在，当初执行力，还算可以，自学java没成功，后面自学单片机，成功入行了。转眼间，毕业到现在有13年了，马上也到了奔4的年纪。这13年一直在跟单片机打交道，打过工，创过业，对行业，对企业，都有一定的认知，坚持看完这篇内容，相信能帮你少走几个月弯路。有些老铁，加了我很久，时

机器学习VS深度学习
nfgo
机器学习
机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领

全面指南：用户行为从前端数据采集到实时处理的最佳实践
数字沉思
营销流量运营系统架构前端内容运营大数据
引言在当今的数据驱动世界，实时数据采集和处理已经成为企业做出及时决策的重要手段。本文将详细介绍如何通过前端JavaScript代码采集用户行为数据、利用API和Kafka进行数据传输、通过Flink实时处理数据的完整流程。无论你是想提升产品体验还是做用户行为分析，这篇文章都将为你提供全面的解决方案。设计一个通用的ClickHouse表来存储用户事件时，需要考虑多种因素，包括事件类型、时间戳、用户信

对于规范和实现，你会混淆吗？
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.