Mybatis——传递参数&&自定义属性和字段的映射

1. MyBatis获取参数的两种方式

执行Sql语句，肯定存在参数的获取，而Mybatis存在两种获取方式：

• ${},这个的实际上就是字符串拼接

• #{}，这个本质是占位符，相当于JDBC中的PrepareStatement。

${}使用字符串拼接的方式拼接sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引 号；但是#{}使用占位符赋值的方式拼接sql，此时为字符串类型或日期类型的字段进行赋值时，可以自 动添加单引号

1.1 单个字面量类型的参数

若mapper中只有一个方法参数，可以使用${} 和

#{}以任意的名称获取参数的值，注意${}需要手动加单引号。

<select id="getUserByName" resultType="Employees">
    select * from employees where first_name = '${name}'; <!--字符串拼接，自己加单引号-->
    select * from employees where first_name = #{name}; <!--占位符，Mybatis自己加-->
</select>
<!--且${name}和#{name}改为#{hhh}也可以获取参数，这里名称可以随便，但不建议这样做-->

1.2 多个字面量类型参数

若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中，以arg0,arg1…为键，以参数为值；以 param1,param2…为键，以参数为值；因此只需要通过${}

和 #{}访问map集合的键就可以获取相对应的 值，注意${}需要手动加单引号

<select id="getUserByAllName" resultType="Employees">
    select * from employees where first_name = #{arg0} and last_name = #{arg1};
</select>

1.3 map集合类型的参数

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中 只需要通过#{}和 $ {}
访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

Map<String, String> map = new HashMap<String, String>();
map.put("firstName", "ww");
map.put("lastName", "hh");
Employees user = mapper.getUserByAllName(map);

<select id="getUserByAllName" resultType="Employees">
    select * from employees where first_name = #{firstName} and last_name = #{lastName};
</select>

1.4 实体类类型的参数

若mapper接口中的方法参数为实体类对象时 此时可以使用${}

和#{}，通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号。实际上就是get方法的反射执行。

1.5 使用@Param标识参数

可以通过@Param注解标识mapper接口中的方法参数 此时，会将这些参数放在map集合中，以@Param注解的value属性值为键，以参数为值；以 param1,param2…为键，以参数为值；只需要通过${}

和#{}访问map集合的键就可以获取相对应的值， 注意${}需要手动加单引号

Employees getUserByAllName(@Param("firstName")String firstName, @Param("lastName")String lastName);

2.Mybatis的查询功能

2.1 查询一个实体类对象

/**
     * 查询单个实体类对象
     */
Employees getEmployeesById(@Param("id") int id);

<select id="getEmployeesById" resultType="Employees">
    select * from employees where employee_id = #{id}
</select>

2.2 查询一个list集合

/**
     * 查询多个实体类对象
     */
List<Employees> getAllEmployee();

<select id="getAllEmployee" resultType="Employees">
    select * from employees
</select>

2.3 查询单个数据

/**
* 查询用户的总记录数
* @return
* 在MyBatis中，对于Java中常用的类型都设置了类型别名
* 例如：java.lang.Integer-->int|integer
* 例如：int-->_int|_integer
* 例如：Map-->map,List-->list
*/
int getCount();

<select id="getCount" resultType="_integer">
    select count(id) from t_user
</select>

2.4 查询一条数据为map集合

/**
     * 将一个查询结果封装进map中
     */
Map<String, Object> getEmployeeToMap(@Param("id")int id);

<select id="getEmployeeToMap" resultType="map">
    select * from employees where employee_id = #{id}
</select>
<!--结果：{password=123456, sex=男, id=1, age=23, username=admin}-->

2.5 查询多条数据为map集合

方式1：List的元素为map

/**
* 查询所有用户信息为map集合
* @return
* 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此
时可以将这些map放在一个list集合中获取
*/
List<Map<String, Object>> getAllUserToMap();

<select id="getEmployeeMapList" resultType="map">
    select * from employees
</select>

方式2：map里面套map，key为查询结果主键

/**
* 查询所有用户信息为map集合
* @return
* 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，并
且最终要以一个map的方式返回数据，此时需要通过@MapKey注解设置map集合的键，值是每条数据所对应的
map集合
*/
@MapKey("id")
Map<String, Object> getAllUserToMap();

<select id="getAllEmployeeMap" resultType="map">
    select * from employees
</select>
<!--{
    1={password=123456, sex=男, id=1, age=23, username=admin},
    2={password=123456, sex=男, id=2, age=23, username=张三},
    3={password=123456, sex=男, id=3, age=23, username=张三}
}-->

---

总结来说：

单个结果可以用实体类对象，list和map存储

多个结果用list或map存储。

3.特殊SQL的执行

平常我们一般用#{}就可以了，但是有些情况我们必须使用${}。因为#{}会自动添加单引号

3.1 模糊查询

List<User> testMohu(@Param("mohu") String mohu);

<select id="testMohu" resultType="User">
    <!--select * from t_user where username like '%${mohu}%'-->
    <!--select * from t_user where username like concat('%',#{mohu},'%')-->
    select * from t_user where username like "%"#{mohu}"%"
</select>

这里如果使用#{},那么实际执行的sql的like后面是 ‘%’mohu‘%’，多了两个单引号，这不符号我们的预期。

3.2 批量删除

int deleteMore(@Param("ids") String ids);

<delete id="deleteMore">
delete from t_user where id in (${ids})
</delete>

in函数中使用’数字’？这就不正确了，所有要使用字符串拼接

3.3 动态设置表名

List<User> getAllUser(@Param("tableName") String tableName);

<select id="getAllUser" resultType="User">
select * from ${tableName}
</select>

3.4 添加功能获取自增的主键

t_clazz(clazz_id,clazz_name) t_student(student_id,student_name,clazz_id)

1、添加班级信息

2、获取新添加的班级的id

3、为班级分配学生，即将某学的班级id修改为新添加的班级的id

/**
* 添加用户信息
* @param user
* @return
* useGeneratedKeys：设置使用自增的主键
* keyProperty：因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参
数user对象的某个属性中
**/
int insertUser(User user);

<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
    insert into t_user values(null,#{username},#{password},#{age},#{sex})
</insert>

4.自定义映射resultMap

之前通过resultType可以将查询出的字段和属性一一对应起来，是因为字段名和属性名称相同，若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射

4.1 resultMap处理字段和属性的映射关系

<!--
    resultMap：设置自定义映射
    属性：
    id：表示自定义映射的唯一标识
    type：查询的数据要映射的实体类的类型
    子标签：
        id：设置主键的映射关系
        result：设置普通字段的映射关系
        association：设置多对一的映射关系（实体类不确定就是多对一）
        collection：设置一对多的映射关系 （属性为list）
        属性：
        property：设置映射关系中实体类中的属性名
        column：设置映射关系中表中的字段名
-->
<resultMap id="userMap" type="User">
    <id property="id" column="id"></id>
    <result property="userName" column="user_name"></result>
    <result property="password" column="password"></result>
    <result property="age" column="age"></result>
    <result property="sex" column="sex"></result>
</resultMap>
<!--List<User> testMohu(@Param("mohu") String mohu);-->
<select id="testMohu" resultMap="userMap">
    <!--select * from t_user where username like '%${mohu}%'-->
    select id,user_name,password,age,sex from t_user where user_name like
    concat('%',#{mohu},'%')
</select>

若字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用_），实体类中的属性 名符合Java的规则（使用驼峰）

此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系

a>可以通过为字段起别名的方式，保证和实体类中的属性名保持一致

b>可以在MyBatis的核心配置文件中设置一个全局配置信息mapUnderscoreToCamelCase，可 以在查询表中数据时，自动将_类型的字段名转换为驼峰

例如：字段名user_name，设置了mapUnderscoreToCamelCase，此时字段名就会转换为 userName

4.2 多对一映射处理

查询员工信息以及员工所对应的部门信息

• 级联方式处理映射关系

  <resultMap id="empDeptMap" type="Emp">
      <id column="eid" property="eid"></id>
      <result column="ename" property="ename"></result>
      <result column="age" property="age"></result>
      <result column="sex" property="sex"></result>
      <result column="did" property="dept.did"></result>
      <result column="dname" property="dept.dname"></result>
  </resultMap>
  <!--Emp getEmpAndDeptByEid(@Param("eid") int eid);-->
  <select id="getEmpAndDeptByEid" resultMap="empDeptMap">
      select emp.*,dept.* from t_emp emp left join t_dept dept on emp.did =
      dept.did where emp.eid = #{eid}
  </select>
  

• 使用association处理映射关系

  <resultMap id="empDeptMap" type="Emp">
      <id column="eid" property="eid"></id>
      <result column="ename" property="ename"></result>
      <result column="age" property="age"></result>
      <result column="sex" property="sex"></result>
      <association property="dept" javaType="Dept">
          <id column="did" property="did"></id>
          <result column="dname" property="dname"></result>
      </association>
  </resultMap>
  <!--Emp getEmpAndDeptByEid(@Param("eid") int eid);-->
  <select id="getEmpAndDeptByEid" resultMap="empDeptMap">
      select emp.*,dept.* from t_emp emp left join t_dept dept on emp.did =
      dept.did where emp.eid = #{eid}
  </select>
  

• 分步查询

  • 查询员工信息

    //通过分步查询查询员工信息
    Emp getEmpByStep(@Param("eid") int eid);
    

    <resultMap id="empDeptStepMap" type="Emp">
        <id column="eid" property="eid"></id>
        <result column="ename" property="ename"></result>
        <result column="age" property="age"></result>
        <result column="sex" property="sex"></result>
    <!--
        select：设置分步查询，查询某个属性的值的sql的标识（namespace.sqlId）Mapper全类名+方法id
        column：将sql以及查询结果中的某个字段设置为分步查询的条件
        -->
        <association property="dept"
      select="com.atguigu.MyBatis.mapper.DeptMapper.getEmpDeptByStep" column="did">
        </association>
        </resultMap>
        <!--Emp getEmpByStep(@Param("eid") int eid);-->
        <select id="getEmpByStep" resultMap="empDeptStepMap">
        select * from t_emp where eid = #{eid}
    </select>
    
    

  • 查询员工信息

    //分步查询的第二步：根据员工所对应的did查询部门信息
    Dept getEmpDeptByStep(@Param("did") int did);
    

    <!--Dept getEmpDeptByStep(@Param("did") int did);-->
    <select id="getEmpDeptByStep" resultType="Dept">
    select * from t_dept where did = #{did}
    </select>
    

4.3 一对多映射处理

• collection

/**
* 根据部门id查新部门以及部门中的员工信息
* @param did
* @return
*/
Dept getDeptEmpByDid(@Param("did") int did);
<resultMap id="deptEmpMap" type="Dept">
    <id property="did" column="did"></id>
    <result property="dname" column="dname"></result>
    <!--
ofType：设置collection标签所处理的集合属性中存储数据的类型
-->
    <collection property="emps" ofType="Emp">
        <id property="eid" column="eid"></id>
        <result property="ename" column="ename"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
    </collection>
</resultMap>
<!--Dept getDeptEmpByDid(@Param("did") int did);-->
<select id="getDeptEmpByDid" resultMap="deptEmpMap">
    select dept.*,emp.* from t_dept dept left join t_emp emp on dept.did =
    emp.did where dept.did = #{did}
</select>

• 分布查询

1）查询部门信息

/**
* 分步查询部门和部门中的员工
* @param did
* @return
*/
Dept getDeptByStep(@Param("did") int did);

<resultMap id="deptEmpStep" type="Dept">
    <id property="did" column="did"></id>
    <result property="dname" column="dname"></result>
    <collection property="emps" fetchType="eager"
                select="com.atguigu.MyBatis.mapper.EmpMapper.getEmpListByDid" column="did">
    </collection>
</resultMap>
<!--Dept getDeptByStep(@Param("did") int did);-->
<select id="getDeptByStep" resultMap="deptEmpStep">
    select * from t_dept where did = #{did}
</select>

2）根据部门id查询部门中的所有员工

/**
* 根据部门id查询员工信息
* @param did
* @return
*/
List<Emp> getEmpListByDid(@Param("did") int did);

<select id="getEmpListByDid" resultType="Emp">
select * from t_emp where did = #{did}
</select>

---

分步查询的优点：可以实现延迟加载，但是必须在核心配置文件中设置全局配置信息：

lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载 .需要调用时，才会执行第二步，第三步的sql

aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个 属性会按需加载

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过association和 collection中的fetchType属性设置当前的分步查询是否使用延迟加载，fetchType=“lazy(延迟加 载)|eager(立即加载)”