缥缈一叶舟

MyBatis3学习笔记

一、MyBatis简介

1.什么是Mybatis

2.MyBatis优点

3.MyBatis历史

二、MyBatis初运行

1.安装MyBatis

2.使用MyBatis示例

3.接口式编程

总结

三、全局配置文件

1.properties属性

2.settings设置

3.typeAliases别名处理器

4.typeHandlers类型处理器

5.plugins插件

6.environments环境

7.databaseIdProvider

8.mapper映射

四、SQL映射文件

1.insert、update、delete元素

2.主键生成方式

3.参数传递

1.单个参数

2.多个参数

3.命名参数

运行成功 4.POJO&Map&To：

4.参数处理

5.select元素

6.自动映射

7.自定义规则resultMap

8.resultMap关联查询

单个对象级联属性封装

association定义关联单个对象封装规则

association分步查询

多对象结果级联查询

多对象结果collection分布查询&延迟查询

discriminator鉴别器

五、动态SQL

1.if

2.trim

3.choose

4.set

5.for each

6.内置参数

7.bind绑定

8.抽取可重用sql片段

六、缓存机制

一级缓存

二级缓存

缓存原理图示

第三方缓存整合

七、MyBatis-Spring整合

八、MyBatis-逆向工程

MyBatis Generator

MBG使用

九、MyBatis工作原理

1、获取sqlSessionFactory对象:

2、获取sqlSession对象

3、获取接口的代理对象（MapperProxy）

4、执行增删改查方法

总结：

十、插件开发

插件原理

插件编写

本次课程的主要内容：MyBatis配置文件编写，MyBatis动态SQL，MyBatis缓存机制，MyBatis-Spring整合，MyBatis逆向工程，MyBatis高级内容（源码解析，单/多插件运行机制，四大对象工作原理，自定义TypeHandler、MyBatis存储过程&游标处理等）。

IDE：IDEA
数据库：mysql 5.7
核心技术：mybatis-3.5.7

一、MyBatis简介

1. MyBatis历史

• 原是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation 迁移到了Google Code，随着开发团队转投Google Code旗下， iBatis3.x正式更名为MyBatis ，代码于2013年11月迁移到Github（下载地址见后）。

• iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。 iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）

2. 什么是Mybatis

• MyBatis是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架。

• MyBatis避免了几乎所有的JDBC代码和手动设参数以及获取结果集的操作。

• MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。

3. MyBatis优点

JDBC的问题

前阶段我们已经学习过的和数据库交互的技术有JDBC中的QueryRunner和Spring中的jdbcTemplate，执行过程大致如下。

SQL夹在Java代码块里，耦合度高导致硬编码内伤
维护不易且实际开发需求中sql是有变化，频繁修改的情况多见

Hibernate的问题

我们进一步采取框架的构想，如Hibernate。其把javabean自动映射成数据库中的一条记录。开发人员只需关心javabean映射成哪个数据记录，不关心实现的过程。

长难复杂SQL，对于Hibernate而言处理也不容易
内部自动生产的SQL，不容易做特殊优化。对发开人员而言，核心SQL还是需要自己优化。
基于全映射的全自动框架，大量字段的POJO进行部分映射时比较困难导致数据库性能下降。

mybatis优势

Mybatis开放了部分操作给开发者。将编写sql的部分提取出来写成一个配置文件，剩下的过程由mybatis封装完成。实现了SQL和java编码解耦，只需要掌握SQL语句。

mybatis是半自动、轻量级的持久层框架。
sql和java编码分开，功能边界清晰，一个专注业务、一个专注数据。

二、MyBatis初运行

1.安装MyBatis

不使用maven情况

要使用MyBatis，只需将mybatis-x.x.x.jar文件置于类路径（classpath）中即可。

访问地址https://github.com/mybatis/mybatis-3/，选择所需要的版本下载相应的jar包和源码包

mybatis的官方文档地址https://mybatis.org/mybatis-3/zh/index.html

解压后：

在IDEA中创建Java工程和相关目录,引入所需jar包,注意将conf文件夹转为配置文件夹（右键--mark Directory as --resources root）

使用maven情况

若使用maven构建项目的话可跳过上述下载导包操作，需将下面的依赖代码置于 pom.xml 文件中：


  org.mybatis
  mybatis
  x.x.x

2.使用MyBatis示例

1. 数据库中创建一张测试表

CREATE TABLE tbl_employee(
	id INT(11) PRIMARY KEY AUTO_INCREMENT,
	last_name VARCHAR(255),
	gender CHAR(1),
	email VARCHAR(255)
)

2.创建对应的javaBean

public class Employee {
    private Integer id;
    private String lastName;
    private String email;
    private String gender;
    ... ...
}

3. 导入相关jar包

其中log4j日志包要能运行，需要在配置文件夹中使用log4j.xml(官网下载直接用)，代码如下

4. 创建mybatis配置文件

MyBatis的全局配置文件包含了影响MyBatis行为甚深的设置和属性信息、如数据库连接池信息以及决定事务作用域和控制方式的事务管理器等,后面会再探讨 XML 配置文件的详细内容。我们先参照官方文件的配置示例。

mybatis-config.xml

注意 XML 头部的声明，它用来验证 XML 文档的正确性。environment 元素体中包含了事务管理和连接池的配置。mappers 元素则包含了一组映射器（mapper），这些映射器的 XML 映射文件包含了 SQL 代码和映射定义信息。

5.根据配置文件创建SqlSessionFactory,从 SqlSessionFactory 中获取 SqlSession，使用sqlsession执行增删改查

MyBatis的应用都是以一个SqlSessionFactory的实例为核心的。SqlSessionFactory 的实例可以通过SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先配置的 Configuration 实例来构建出 SqlSessionFactory 实例。

从 XML 文件中构建 SqlSessionFactory 的实例非常简单，建议使用类路径下的资源文件进行配置。MyBatis 包含一个名叫 Resources 的工具类，它包含一些实用方法，使得从类路径或其它位置加载资源文件更加容易。

public class MybatisText {
    /**
     * 1.根据xml配置文件(全局配置文件)创建一个SqlSessionFactory对象
     * 2.
     * @throws IOException
     */
    @Test
    public void test() throws IOException {
        //1.根据全局配置文件，利用SqlSessionFactoryBuilder创建SqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //2.使用SqlSessionFactory获取sqlSession对象,能直接执行已映射的sql语句。一个SqlSession对象代表和数据库的一次会话。
        SqlSession openSession = sqlSessionFactory.openSession();
                //3.使用SqlSession根据方法id进行操作
                try {
                    //1.sql的唯一标识，通常namespace+id的方式
                    //2.执行sql要用的参数
                    Employee employee = openSession.selectOne("com.atguigu.mybatis.EmployeeMapper.selectEmp",1);
                    System.out.println(employee);
                } finally {
                    openSession.close();
                }
    }

6. 创建SQL映射文件
映射文件的作用就相当于是定义Dao接口的实现类如何工作。这也是我们使用MyBatis时编写的最多的文件。

EmployeeMapper.xml

7.测试

步骤总结：
1.创建全局配置文件
2.根据全局配置文件创建SqlSessionFactory对象
3.创建sql映射文件(配置了每一个sql，以及sql的封装规则等)
4.将sql映射文件注册在全局配置文件中

细节：
1.根据配置文件创建SqlSessionFactory,从 SqlSessionFactory 中获取 SqlSession，使用sqlsession执行增删改查。一个sqlSession就是代表和数据库的一次会话，用完关闭
2.使用sql的唯一标志来告诉MyBatis执行哪个sql(后面我们采用接口编程的方法取代)。sql都是保存在sql映射文件中的。

3.接口式编程

SqlSession可以直接调用方法的唯一标注(namespace+id)进行数据库操作，但是我们一般还是推荐使用SqlSession获取到Dao接口的代理类，执行代理对象的方法，可以更安全的进行类型检查操作。

1.创建一个Dao接口

public interface EmployeeMapper {
    public Employee getEmpById(Integer id);
}

2.修改Mapper文件

	public SqlSessionFactory getSqlSessionFactory() throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		return new SqlSessionFactoryBuilder().build(inputStream);
	}
	
    @Test
	public void test01() throws IOException {
		// 1、获取sqlSessionFactory对象
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		// 2、获取sqlSession对象
		SqlSession openSession = sqlSessionFactory.openSession();
		try {
			// 3、获取接口的实现类对象
			//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			Employee employee = mapper.getEmpById(1);
			System.out.println(mapper.getClass());
			System.out.println(employee);
		} finally {
			openSession.close();
		}
	}

employeeMapper.xml

采用接口编程方法的好处：

拥有更强的类型检查，有明确的返回值，将dao层的规范和实现分离出来，方便开发扩展。

总结

1、接口式编程
    未使用mybatis之前，一个dao接口对应一个实现类；使用mybatis后，dao接口以XXXMapper命名,有一个与之对应的sql映射文件
    原生： Dao        ====> DaoImpl
    mybatis：    Mapper    ====> xxMapper.xml
2、SqlSession代表和数据库的一次会话，用完必须关闭；
3、SqlSession和connection一样都是非线程安全。每次使用都应该去获取新的对象。
4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。（将接口和xml进行绑定）
       EmployeeMapper empMapper =   sqlSession.getMapper(EmployeeMapper.class);
5、两个重要的配置文件：
       mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
       sql映射文件：保存了每一个sql语句的映射信息：将sql抽取出来。

三、全局配置文件

MyBatis的配置文件包含了影响 MyBatis 行为甚深的设置（settings）和属性（properties）信息。文档的顶层结构如下：

1.properties属性

1、mybatis可以使用properties来引入外部properties配置文件的内容；
resource：引入类路径下的资源
url：引入网络路径或者磁盘路径下的资源

示例：类路径下有dbconfig.properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=123456

mybatis-config.xml(此部分后续会和spring整合，此形式不常用了)

• 如果属性在不只一个地方进行了配置，那么 MyBatis 将按照下面的顺序来加载：
在 properties 元素体内指定的属性首先被读取。
然后根据 properties 元素中的 resource 属性读取类路径下属性文件或根据 url 属性指定的路径读取属性文件，并覆盖已读取的同名属性。
最后读取作为方法参数传递的属性，并覆盖已读取的同名属性。

2.settings设置

这是MyBatis中极为重要的调整设置，它们会改变MyBatis的运行时行为。(边用边学)

settings包含很多重要的设置项
   setting:用来设置每一个设置项
       name：设置项名
       value：设置项取值

3.typeAliases别名处理器

别名处理器可以为我们的java类型起别名，别名不区分大小写。类型别名可以方便我们引用某个类。（一般为了好找写好的类，我们还是会使用全类名的方式）

1、typeAlias:为某个java类型起别名
type:指定要起别名的类型的类名，默认别名就是类名小写
alias:指定新的别名

类很多的情况下，可以批量设置别名。这个包下的每一个类创建一个默认的别名，就是简单类名小写。

2.package:为某个包下的所有类批量起别名
name：指定包名（为当前包以及下面所有的后代包的每一个类都起一个默认别名（类名小写））

3.为避免批量起别命名带来冲突(包和子包有同名类)，使用@Alias注解为某个类型指定新的别名

@Alias("emp")
public class Employee {
    private Integer id;
    private String lastName;
    ......
}

值得注意的是，MyBatis已经为许多常见的 Java 类型内建了相应的类型别名。它们都是大小写不敏感的，我们在起别名的时候千万不要占用已有的别名。

4.typeHandlers类型处理器

无论是MyBatis在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。

作用：架起java类型和数据库类型一一映射的桥梁

日期类型的处理
日期和时间的处理，JDK1.8以前一直是个头疼的问题。我们通常使用JSR310规范领导者Stephen Colebourne创建的Joda-Time来操作。1.8已经实现全部的JSR310规范了。
• 日期时间处理上，我们可以使用MyBatis基于JSR310（Date and Time API）编写的各种日时间类型处理器。
• MyBatis3.4以前的版本需要我们手动注册这些处理器，以后的版本都是自动注册

自定义类型处理器
我们可以重写类型处理器或创建自己的类型处理器来处理不支持的或非标准的类型。(放到后部分学习)
步骤：
• 1 实现org.apache.ibatis.type.TypeHandler接口或者继承org.apache.ibatis.type.BaseTypeHandler
• 2 指定其映射某个JDBC类型（可选操作）
• 3 在mybatis全局配置文件中注册

5.plugins插件

等后续讲完mybatis运行原理后细讲，先做简单介绍

插件是MyBatis提供的一个非常强大的机制，我们可以通过插件来修改MyBatis的一些核心行为。插件通过动态代理机制，可以介入四大对象的任何一个方法的执行。后面会有专门的章节我们来介绍mybatis运行原理以及插件
• Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
• ParameterHandler (getParameterObject, setParameters)
• ResultSetHandler (handleResultSets, handleOutputParameters)
• StatementHandler (prepare, parameterize, batch, update, query)

6.environments环境

• MyBatis可以配置多种环境，比如开发、测试和生产环境需要有不同的配置

• 每种环境使用一个environment标签进行配置并指定唯一标识符

• 可以通过environments标签中的default属性指定一个环境的标识符来快速的切换环境

environment-指定具体环境

• id：指定当前环境的唯一标识

• transactionManager、和dataSource子标签都必须有

transactionManager标签：事务管理器；(我们通常交给spring完成事务管理，了解即可)

type： JDBC | MANAGED | 自定义
        – JDBC：使用了 JDBC 的提交和回滚设置，依赖于从数据源得到的连接来管理事务范围。
        JdbcTransactionFactory的别名
        – MANAGED：不提交或回滚一个连接、让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 ManagedTransactionFactory
        – 自定义：实现TransactionFactory接口，type=全类名/别名

dataSource标签
• type： UNPOOLED | POOLED | JNDI | 自定义
– UNPOOLED：不使用连接池，UnpooledDataSourceFactory
– POOLED：使用连接池， PooledDataSourceFactory
– JNDI：在EJB 或应用服务器这类容器中查找指定的数据源
– 自定义：实现DataSourceFactory接口，定义数据源的获取方式。
实际开发中我们使用Spring管理数据源，并进行事务控制的配置来覆盖上述配置别名

7.databaseIdProvider

MyBatis支持多数据库厂商，使用databaseIdProvider标签可以根据不同的数据库厂商执行不同的语句

Type： DB_VENDOR
– 使用MyBatis提供的VendorDatabaseIdProvider解析数据库厂商标识。也可以实现DatabaseIdProvider接口来自定义。
• Property-name：数据库厂商标识
• Property-value：为标识起一个别名，方便SQL语句使用databaseId属性引用

MyBatis匹配规则如下：
– 1、如果没有配置databaseIdProvider标签，那么databaseId=null
– 2、如果配置了databaseIdProvider标签，使用标签配置的name去匹配数据库信息，匹配上设置databaseId=配置指定的值，否则依旧为null
– 3、如果databaseId不为null，他只会找到配置databaseId的sql语句
– 4、MyBatis 会加载不带 databaseId 属性和带有匹配当前数据库 databaseId 属性的所有语句。如果同时找到带有 databaseId 和不带databaseId 的相同语句，则不带标识的会被舍弃。

8.mapper映射

将sql映射注册到全局配置中

public interface EmployeeMapperAnnotation {
	
	@Select("select * from tbl_employee where id=#{id}")
	public Employee getEmpById(Integer id);
}

四、SQL映射文件

映射文件指导着MyBatis如何进行数据库增删改查，有着非常重要的意义；

1.insert、update、delete元素

接口：

public interface EmployeeMapper {
    public Employee getEmpById(Integer id);
    
    public void addEmp(Employee employee);
    
    public void deleteEmp(Integer id);
    
    public void updateEmp(Employee employee);
}

映射文件EmployeeMapper.xml：





    



    
        insert into tbl_employee(last_name,email,gener) value (#{lastName},#{email},#{gender})
    


    
        delete from tbl_employee where id=#{id}
    

    
        update tbl_employee set last_name = #{lastName},email=#{email},gender=#{gender}

功能测试：

 @Test
    public void test2() throws IOException {
        //根据全局配置文件，利用SqlSessionFactoryBuilder创建SqlSessionFactory
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        //1.获取到的sqlSession不会自动提交数据
        SqlSession openSession = sqlSessionFactory.openSession();
        try {
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            //测试添加
            //Employee employee = new Employee(null, "jerry", "jerry@email", "0");
            //mapper.addEmp(employee);
            //测试更新
            //Employee employee = new Employee(2, "jerry", "jerry@email", "0");
            //mapper.updateEmp(employee);
            //测试删除
            mapper.deleteEmp(2);
            //2.手动提交数据
            openSession.commit();
        }finally {
            openSession.close();
        }
    }

1.mybatis允许增删改直接定义以下类型返回值 Integer、Long、Boolean、void。(运行sql语句后返回的值)

public Integer addEmp(Employee employee);

 Integer integer = mapper.addEmp(employee);

2.我们需要手动提交数据

sqlSessionFactory.openSession();手动提交
sqlSessionFactory.openSession(true);自动提交

2.主键生成方式

• 获取自增主键的值：
mysql支持自增主键。自增主键值的获取，mybatis和原生JDBC一样也是利用statement.getGenreatedKeys()获取；
useGeneratedKeys="true" 使用自增主键获取主键值策略
keyProperty 指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性


		insert into tbl_employee(last_name,email,gender) 
		values(#{lastName},#{email},#{gender})

 Employee employee = new Employee(null, "je", "jerry@email", "0");
 mapper.addEmp(employee);
 System.out.println(employee.getId());//能获取到非空的主键值

• 获取非自增主键的值：
Oracle不支持自增主键，Oracle使用序列来模拟自增；
每次插入的数据的主键是从序列中拿到的值，如何获取到这个值；


		
		
			
			
			select EMPLOYEES_SEQ.nextval from dual 
			
		
		
		
		
		insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
		values(#{id},#{lastName},#{email})

3.参数传递

1.单个参数

mybatis不会做特殊处理，
#{参数名/任意名}：取出参数值。

2.多个参数

mybatis会做特殊处理。

示例：

测试

try{
    EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
    Employee employee = mapper.getEmpByIdAndLastName(1, "tom");
    System.out.println(employee);
}

运行结果：

异常报错：
   org.apache.ibatis.binding.BindingException:
   Parameter 'id' not found.
   Available parameters are [1, 0, param1, param2]
   操作：
       方法：public Employee getEmpByIdAndLastName(Integer id,String lastName);
       取值：#{id},#{lastName}

原因分析：
多个参数会被封装成一个map，key：param1...paramN,或者参数的索引也可以
value：传入的参数值

修正：

上述修正方法可以正常使用，但参数命名比较模糊，改进：

3.命名参数

【命名参数】：明确指定封装参数时map的key；@Param("id")
            多个参数会被封装成一个map，
                key：使用@Param注解指定的值
                value：参数值
#{指定的key}取出对应的参数值

改进后写法：

测试：

try{
    EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
    Employee employee = mapper.getEmpByIdAndLastName(1, "tom");
    System.out.println(employee);
}

运行成功

4.POJO&Map&To：

如果多个参数正好是我们业务逻辑的数据模型，我们就可以直接传入pojo；
#{属性名}：取出传入的pojo的属性值

如果多个参数不是业务模型中的数据，没有对应的pojo，不会经常使用到，为了方便，我们也可以传入map
#{key}：取出map中对应的值

try{
    EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
    Map map = new HashMap<>();
    map.put("id", 2);
    map.put("lastName", "Tom");
    Employee employee = mapper.getEmpByMap(map);
    System.out.println(employee);
}

如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象
Page{
int index;
int size;
}

思考：
public Employee getEmp(@Param("id")Integer id,String lastName);
取值：id==>#{id/param1} lastName==>#{param2}

public Employee getEmp(Integer id,@Param("e")Employee emp);
取值：id==>#{param1} lastName===>#{param2.lastName/e.lastName}

##特别注意：如果是Collection（List、Set）类型或者是数组，也会特殊处理。也是把传入的list或者数组封装在map中。
           key：Collection（collection）,如果是List还可以使用这个key(list)，数组(array)
public Employee getEmpById(List ids);
   取值：取出第一个id的值： #{list[0]}

结合源码，mybatis怎么处理参数（了解内容）

总结：参数多时会封装map，为了不混乱，我们可以使用@Param来指定封装时使用的key；
#{key}就可以取出map中的值；

EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
Employee employee = mapper.getEmpByIdAndLastName(1, "tom");

mapper是代理对象。

paramNameResolver是解析参数封装map的源码

public Object getNamedParams(Object[] args) {
        int paramCount = this.names.size();
        if (args != null && paramCount != 0) {
            if (!this.hasParamAnnotation && paramCount == 1) {//只有一个元素并且没有注解
                Object value = args[(Integer)this.names.firstKey()];
                return wrapToMapIfCollection(value, this.useActualParamName ? (String)this.names.get(0) : null);
            } else {
                Map param = new ParamMap();
                int i = 0;

                for(Iterator var5 = this.names.entrySet().iterator(); var5.hasNext(); ++i) {
                    Entry entry = (Entry)var5.next();
                    param.put(entry.getValue(), args[(Integer)entry.getKey()]);
                    String genericParamName = "param" + (i + 1);
                    if (!this.names.containsValue(genericParamName)) {
                        param.put(genericParamName, args[(Integer)entry.getKey()]);
                    }
                }

                return param;
            }
        } else {
            return null;
        }
    }

(@Param("id")Integer id,@Param("lastName")String lastName);
//1、names：{0=id, 1=lastName}；构造器的时候就确定好了

确定流程：
   1.获取每个标了param注解的参数的@Param的值：id，lastName；赋值给name;
   2.每次解析一个参数给map中保存信息：（key：参数索引，value：name的值）
       name的值：
           标注了param注解：注解的值
           没有标注：
               1.全局配置：useActualParamName（jdk1.8）：name=参数名
               2.name=map.size()；相当于当前元素的索引
   {0=id, 1=lastName,2=2}

args【1，"Tom",'hello'】:

public Object getNamedParams(Object[] args) {
    final int paramCount = names.size();
    //1、参数为null直接返回
    if (args == null || paramCount == 0) {
      return null;
     
    //2、如果只有一个元素，并且没有Param注解；args[0]：单个参数直接返回
    } else if (!hasParamAnnotation && paramCount == 1) {
      return args[names.firstKey()];
      
    //3、多个元素或者有Param标注
    } else {
      final Map param = new ParamMap