二、mybatis的入参
MyBatis参数可以传入（1）单个参数；（2）多个参数；（3）封装为Map；（4）对象传入。
2.1 单个参数：
映射器类UserMapper.java接口方法:
User queryUserById(int id);
映射文件UserMapper.xml对应方法:
<select id="queryUserById" resultType="com.whfc.mybatis.entity.User">
select
id,
username,
age
from user
where id = #{id}
</select>
测试：
User user1 = userMapper.queryUserById(1);
2.2 多个参数:
映射器类UserMapper.java接口方法:
User queryUserByIdAndUserName(int id, String userName);
映射文件UserMapper.xml对应方法:
<!-- 多个参数 -->
<select id="queryUserByIdAndUserName" resultType="com.whfc.mybatis.entity.User">
select
id,
username,
userage
from user
where id = #{id} and username = #{userName}
</select>
<!-- 经过测试，上述写法不成功 -->
测试：
// ***多个参数***
User user2 = userMapper.queryUserByIdAndUserName(1, "one");
运行结果：
运行抛出异常了，异常内容摘要如下：
Parameter 'id' not found. Available parameters are [arg1, arg0, param1, param2]
明明我们传入了id，为什么会出现这个情况？
MyBatis关于多个参数处理时，会把多个参数转换为Map，其键值key为param1，param2…，而value值没变，还是传入的值，但是我们的UserMapper.xml中通过#{id}，#{userName}去取参数值，因为找不到对应的key，所以会报找不到id的异常。
解决办法：可以将#{id}，#{userName}修改为#{param1}，#{param2}： 于是乎这样是正确的：
<!-- 多个参数 -->
<select id="queryUserByIdAndUserName" resultType="com.whfc.mybatis.entity.User">
select
id,
userName,
userage
from user
where id = #{param1} and username = #{param2}
</select>
但是新的问题产生，不直观，为了使代码有含义、可读、可维护，还是使用#{id}、#{userName}比较合适，所以我们需要做下修改，修改MyBatis多个参数传入时的默认key值param1，param2 为我们自己的id、userName
解决办法：通过@Param注解将UseMapper.java查询自定义Map的key值
//@Param注解自定义传入参数的key值
User queryUserByIdAndUserName(@Param("id") int id, @Param("userName") String userName);
2.3 以Map做参数传值：
一般当参数较多时，用很过个@Param去逐个自定义过于麻烦，参数列表看上去要多大就有多大，为了改变这种方式，我们可以将参数主动封装为Map，作为方法参数传入。
映射器类UserMapper.java接口方法：
/* Map参数封装 */
User queryUserByMap(Map<String, Object> map);
映射文件UserMapper.xml对应方法：
<!-- 多个参数Map -->
<select id="queryUserByMap" resultType="com.whfc.mybatis.entity.User">
select
id,
userName,
userage
from user
where id = #{id} and username = #{userName} and userage = #{userAge}
</select>
测试：
// ***多个参数封装成Map***
Map<String, Object> paramMap = new HashMap<>();
paramMap.put("id", 1);
paramMap.put("userName", "one");
paramMap.put("userAge", "25");
User user3 = userMapper.queryUserByMap(paramMap);
2.4 对象做参数：
多个参数封装成Map需要一个参数一个参数的添加put，万一那个参数put的key搞错了，也是个麻烦事，这时我们也可以将参数封装为一个对象传入。
传入参数对象：
package com.whfc.mybatis.param;
/**
* 请求对象
* @author likang
* @date 2018/6/25 11:03
*/
public class UserReq {
private Integer id;
//用户名
private String userName;
//用户年纪
private Integer userAge;
//用户电话
private String userPhone;
//get和set方法省略
public Integer getId() { return id; }
public void setId(Integer id) { this.id = id; }
}
映射器类UserMapper.java接口方法：
/* 对象参数封装 */
User queryUserByPojo(UserReq req);
映射文件UserMapper.xml对应方法：
<!-- 多个参数POJO -->
<select id="queryUserByPojo" parameterType="com.whfc.mybatis.param.UserReq"
resultType="com.whfc.mybatis.entity.User">
select
id,
userName,
userage,
userphone
from user
where id = #{id} and username = #{userName} and userage = #{userName} and userphone = #{userPhone}
</select>
测试：
// ***多个参数封装成对象***
UserReq req = new UserReq();
req.setId(1);
req.setUserName("one");
req.setUserAge(26);
req.setUserPhone("13232323245")
User user4 = userMapper.queryUserByPojo(req);
2.5 参数传递的注意事项
1、如果传入的参数有可能为空null，则需要在映射文件中指定参数的类型，jdbcType=数据数据类型 示例如下：
<!-- 多个参数POJO -->
<select id="queryUserByPojo" parameterType="com.whfc.mybatis.param.UserReq"
resultType="com.whfc.mybatis.entity.User">
select
id,
userName,
userage,
userphone
from user
where id = #{id} and username = #{userName,jdbcType=VARCHAR} and userage = #{userAge,jdbcType=INTEGER}
and userphone = #{userPhone,jdbcType=VARCHAR}
</select>
2、#{key} 与 ${key} 的区别：
（1）#{key}：获取参数的值，预编译到SQL中。安全。
（2）${key}：获取参数的值，拼接到SQL中。有SQL注入问题。ORDER BY ${name}
三、mybatis的出参resultMap
一般映射文件的查询结果resultType类型可直接使用用程序中的POJO对象：resultType="com.whfc.mybatis.entity.User"，但是引入多表的概念后， 存在两种情况：
（1）表中字段与 程序不一致；
（2）级联查询，
此时需要在映射文件中引入 自定义结果集resultMap 。
3.1 resultMap:自定义结果集
<mapper namespace="com.atguigu.mybatis.dao.EmployeeMapperPlus">
<!--自定义某个javaBean的封装规则
type：自定义规则的Java类型
id:唯一id方便引用
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MySimpleEmp">
<!--指定主键列的封装规则
id定义主键会底层有优化；
column：指定哪一列
property：指定对应的javaBean属性
-->
<id column="id" property="id"/>
<!-- 定义普通列封装规则 -->
<result column="last_name" property="lastName"/>
<!-- 其他不指定的列会自动封装：我们只要写resultMap就把全部的映射规则都写上。 -->
<result column="email" property="email"/>
<result column="gender" property="gender"/>
</resultMap>
<!-- resultMap:自定义结果集映射规则； -->
<!-- public Employee getEmpById(Integer id); -->
<select id="getEmpById" resultMap="MySimpleEmp">
select * from tbl_employee where id=#{id}
</select>
<!--
场景一：
查询Employee的同时查询员工对应的部门
Employee===Department
一个员工有与之对应的部门信息；
id last_name gender d_id did dept_name (private Department dept;)
-->
<!--
联合查询：级联属性封装结果集
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<result column="did" property="dept.id"/>
<result column="dept_name" property="dept.departmentName"/>
</resultMap>
<!--
使用association定义关联的单个对象的封装规则；
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyDifEmp2">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<!-- association可以指定联合的javaBean对象
property="dept"：指定哪个属性是联合的对象
javaType:指定这个属性对象的类型[不能省略]
-->
<association property="dept" javaType="com.atguigu.mybatis.bean.Department">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
</association>
</resultMap>
<!-- public Employee getEmpAndDept(Integer id);-->
<select id="getEmpAndDept" resultMap="MyDifEmp">
SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
WHERE e.d_id=d.id AND e.id=#{id}
</select>
<!-- 使用association进行分步查询：
1、先按照员工id查询员工信息
2、根据查询员工信息中的d_id值去部门表查出部门信息
3、部门设置到员工中；
-->
<!-- id last_name email gender d_id -->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpByStep">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!-- association定义关联对象的封装规则
select:表明当前属性是调用select指定的方法查出的结果
column:指定将哪一列的值传给这个方法
流程：使用select指定的方法（传入column指定的这列参数的值）查出对象，并封装给property指定的属性
-->
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</resultMap>
<!-- public Employee getEmpByIdStep(Integer id);-->
<select id="getEmpByIdStep" resultMap="MyEmpByStep">
select * from tbl_employee where id=#{id}
<if test="_parameter!=null">
and 1=1
</if>
</select>
<!-- 可以使用延迟加载（懒加载）；(按需加载)
Employee==>Dept：
我们每次查询Employee对象的时候，都将一起查询出来。
部门信息在我们使用的时候再去查询；
分段查询的基础之上加上两个配置：
-->
<!-- ================================association========================================== -->
<!--
场景二：
查询部门的时候将部门对应的所有员工信息也查询出来：注释在DepartmentMapper.xml中
-->
<!-- public List<Employee> getEmpsByDeptId(Integer deptId); -->
<select id="getEmpsByDeptId" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee where d_id=#{deptId}
</select>
<!-- =====================================鉴别器========================================== -->
<!-- <discriminator javaType=""></discriminator>
鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为
封装Employee：
如果查出的是女生：就把部门信息查询出来，否则不查询；
如果是男生，把last_name这一列的值赋值给email;
-->
<resultMap type="com.atguigu.mybatis.bean.Employee" id="MyEmpDis">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
<!--
column：指定判定的列名
javaType：列值对应的java类型 -->
<discriminator javaType="string" column="gender">
<!--女生 resultType:指定封装的结果类型；不能缺少。/resultMap-->
<case value="0" resultType="com.atguigu.mybatis.bean.Employee">
<association property="dept"
select="com.atguigu.mybatis.dao.DepartmentMapper.getDeptById"
column="d_id">
</association>
</case>
<!--男生 ;如果是男生，把last_name这一列的值赋值给email; -->
<case value="1" resultType="com.atguigu.mybatis.bean.Employee">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="last_name" property="email"/>
<result column="gender" property="gender"/>
</case>
</discriminator>
</resultMap>
</mapper>
3.2 association 与 collection
3.2.1 association定义关联的单个对象 一对一
3.2.2 collection 定义关联的集合类型 一对多
<mapper namespace="com.atguigu.mybatis.dao.DepartmentMapper">
<!--public Department getDeptById(Integer id); -->
<select id="getDeptById" resultType="com.atguigu.mybatis.bean.Department">
select id,dept_name departmentName from tbl_dept where id=#{id}
</select>
<!--
public class Department {
private Integer id;
private String departmentName;
private List<Employee> emps;
did dept_name || eid last_name email gender
-->
<!--嵌套结果集的方式，使用collection标签定义关联的集合类型的属性封装规则 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDept">
<id column="did" property="id"/>
<result column="dept_name" property="departmentName"/>
<!--
collection定义关联集合类型的属性的封装规则
ofType:指定集合里面元素的类型
-->
<collection property="emps" ofType="com.atguigu.mybatis.bean.Employee">
<!-- 定义这个集合中元素的封装规则 -->
<id column="eid" property="id"/>
<result column="last_name" property="lastName"/>
<result column="email" property="email"/>
<result column="gender" property="gender"/>
</collection>
</resultMap>
<!-- public Department getDeptByIdPlus(Integer id); -->
<select id="getDeptByIdPlus" resultMap="MyDept">
SELECT d.id did,d.dept_name dept_name,
e.id eid,e.last_name last_name,e.email email,e.gender gender
FROM tbl_dept d
LEFT JOIN tbl_employee e
ON d.id=e.d_id
WHERE d.id=#{id}
</select>
<!-- collection：分段查询 -->
<resultMap type="com.atguigu.mybatis.bean.Department" id="MyDeptStep">
<id column="id" property="id"/>
<id column="dept_name" property="departmentName"/>
<collection property="emps"
select="com.atguigu.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
column="{deptId=id}" fetchType="lazy"></collection>
</resultMap>
<!-- public Department getDeptByIdStep(Integer id); -->
<select id="getDeptByIdStep" resultMap="MyDeptStep">
select id,dept_name from tbl_dept where id=#{id}
</select>
<!-- 扩展：多列的值传递过去：
将多列的值封装map传递；
column="{key1=column1,key2=column2}"
fetchType="lazy"：表示使用延迟加载；
- lazy：延迟
- eager：立即
-->
</mapper>
四、动态SQL：
<mapper namespace="com.atguigu.mybatis.dao.EmployeeMapperDynamicSQL">
<!--
• if:判断
• choose (when, otherwise):分支选择；带了break的swtich-case
如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个
• trim 字符串截取(where(封装查询条件), set(封装修改条件))
• foreach 遍历集合
-->
<!-- 查询员工，要求，携带了哪个字段查询条件就带上这个字段的值 -->
<!-- public List<Employee> getEmpsByConditionIf(Employee employee); -->
<select id="getEmpsByConditionIf" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!-- where -->
<where>
<!-- test：判断表达式（OGNL）
OGNL参照PPT或者官方文档。
c:if test
从参数中取值进行判断
遇见特殊符号应该去写转义字符：
&&：
-->
<if test="id!=null">
id=#{id}
</if>
<if test="lastName!=null && lastName!=""">
and last_name like #{lastName}
</if>
<if test="email!=null and email.trim()!=""">
and email=#{email}
</if>
<!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
<if test="gender==0 or gender==1">
and gender=#{gender}
</if>
</where>
</select>
<!--public List<Employee> getEmpsByConditionTrim(Employee employee); -->
<select id="getEmpsByConditionTrim" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!-- 后面多出的and或者or where标签不能解决
prefix="":前缀：trim标签体中是整个字符串拼串 后的结果。
prefix给拼串后的整个字符串加一个前缀
prefixOverrides="":
前缀覆盖： 去掉整个字符串前面多余的字符
suffix="":后缀
suffix给拼串后的整个字符串加一个后缀
suffixOverrides=""
后缀覆盖：去掉整个字符串后面多余的字符
-->
<!-- 自定义字符串的截取规则 -->
<trim prefix="where" suffixOverrides="and">
<if test="id!=null">
id=#{id} and
</if>
<if test="lastName!=null && lastName!=""">
last_name like #{lastName} and
</if>
<if test="email!=null and email.trim()!=""">
email=#{email} and
</if>
<!-- ognl会进行字符串与数字的转换判断 "0"==0 -->
<if test="gender==0 or gender==1">
gender=#{gender}
</if>
</trim>
</select>
<!-- public List<Employee> getEmpsByConditionChoose(Employee employee); -->
<select id="getEmpsByConditionChoose" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<where>
<!-- 如果带了id就用id查，如果带了lastName就用lastName查;只会进入其中一个 -->
<choose>
<when test="id!=null">
id=#{id}
</when>
<when test="lastName!=null">
last_name like #{lastName}
</when>
<when test="email!=null">
email = #{email}
</when>
<otherwise>
gender = 0
</otherwise>
</choose>
</where>
</select>
<!--public void updateEmp(Employee employee); -->
<update id="updateEmp">
<!-- Set标签的使用 -->
update tbl_employee
<set>
<if test="lastName!=null">
last_name=#{lastName},
</if>
<if test="email!=null">
email=#{email},
</if>
<if test="gender!=null">
gender=#{gender}
</if>
</set>
where id=#{id}
<!--
Trim：更新拼串
update tbl_employee
<trim prefix="set" suffixOverrides=",">
<if test="lastName!=null">
last_name=#{lastName},
</if>
<if test="email!=null">
email=#{email},
</if>
<if test="gender!=null">
gender=#{gender}
</if>
</trim>
where id=#{id} -->
</update>
<!--public List<Employee> getEmpsByConditionForeach(List<Integer> ids); -->
<select id="getEmpsByConditionForeach" resultType="com.atguigu.mybatis.bean.Employee">
select * from tbl_employee
<!--
collection：指定要遍历的集合：
list类型的参数会特殊处理封装在map中，map的key就叫list
item：将当前遍历出的元素赋值给指定的变量
separator:每个元素之间的分隔符
open：遍历出所有结果拼接一个开始的字符
close:遍历出所有结果拼接一个结束的字符
index:索引。遍历list的时候是index就是索引，item就是当前值
遍历map的时候index表示的就是map的key，item就是map的值
#{变量名}就能取出变量的值也就是当前遍历出的元素
-->
<foreach collection="ids" item="item_id" separator=","
open="where id in(" close=")">
#{item_id}
</foreach>
</select>
<!-- 批量保存 -->
<!--public void addEmps(@Param("emps")List<Employee> emps); -->
<!--MySQL下批量保存：可以foreach遍历 mysql支持values(),(),()语法-->
<insert id="addEmps">
insert into tbl_employee(
<include refid="insertColumn"></include>
)
values
<foreach collection="emps" item="emp" separator=",">
(#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
</foreach>
</insert><!-- -->
<!-- 这种方式需要数据库连接属性allowMultiQueries=true；
这种分号分隔多个sql可以用于其他的批量操作（删除，修改） -->
<!-- <insert id="addEmps">
<foreach collection="emps" item="emp" separator=";">
insert into tbl_employee(last_name,email,gender,d_id)
values(#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
</foreach>
</insert> -->
<!-- Oracle数据库批量保存：
Oracle不支持values(),(),()
Oracle支持的批量方式
1、多个insert放在begin - end里面
begin
insert into employees(employee_id,last_name,email)
values(employees_seq.nextval,'test_001','test_001@atguigu.com');
insert into employees(employee_id,last_name,email)
values(employees_seq.nextval,'test_002','test_002@atguigu.com');
end;
2、利用中间表：
insert into employees(employee_id,last_name,email)
select employees_seq.nextval,lastName,email from(
select 'test_a_01' lastName,'test_a_e01' email from dual
union
select 'test_a_02' lastName,'test_a_e02' email from dual
union
select 'test_a_03' lastName,'test_a_e03' email from dual
)
-->
<insert id="addEmps" databaseId="oracle">
<!-- oracle第一种批量方式 -->
<!-- <foreach collection="emps" item="emp" open="begin" close="end;">
insert into employees(employee_id,last_name,email)
values(employees_seq.nextval,#{emp.lastName},#{emp.email});
</foreach> -->
<!-- oracle第二种批量方式 -->
insert into employees(
<!-- 引用外部定义的sql -->
<include refid="insertColumn">
<property name="testColomn" value="abc"/>
</include>
)
<foreach collection="emps" item="emp" separator="union"
open="select employees_seq.nextval,lastName,email from("
close=")">
select #{emp.lastName} lastName,#{emp.email} email from dual
</foreach>
</insert>
<!-- 两个内置参数：
不只是方法传递过来的参数可以被用来判断，取值。。。
mybatis默认还有两个内置参数：
_parameter:代表整个参数
单个参数：_parameter就是这个参数
多个参数：参数会被封装为一个map；_parameter就是代表这个map
_databaseId:如果配置了databaseIdProvider标签。
_databaseId就是代表当前数据库的别名oracle
-->
<!--public List<Employee> getEmpsTestInnerParameter(Employee employee); -->
<select id="getEmpsTestInnerParameter" resultType="com.atguigu.mybatis.bean.Employee">
<!-- bind：可以将OGNL表达式的值绑定到一个变量中，方便后来引用这个变量的值 -->
<bind name="_lastName" value="'%'+lastName+'%'"/>
<if test="_databaseId=='mysql'">
select * from tbl_employee
<if test="_parameter!=null">
where last_name like #{lastName}
</if>
</if>
<if test="_databaseId=='oracle'">
select * from employees
<if test="_parameter!=null">
where last_name like #{_parameter.lastName}
</if>
</if>
</select>
<!--
抽取可重用的sql片段。方便后面引用
1、sql抽取：经常将要查询的列名，或者插入用的列名抽取出来方便引用
2、include来引用已经抽取的sql：
3、include还可以自定义一些property，sql标签内部就能使用自定义的属性
include-property：取值的正确方式${prop},
#{不能使用这种方式}
-->
<sql id="insertColumn">
<if test="_databaseId=='oracle'">
employee_id,last_name,email
</if>
<if test="_databaseId=='mysql'">
last_name,email,gender,d_id
</if>
</sql>
</mapper>
五、mybatis的分页插件实现
package com.whfc.ms.controller;
import java.util.List;
@RestController
@RequestMapping("/test")
public class HelloLikangContorller {
@Autowired
private SysRoleMapper sysRoleMapper;
@GetMapping("/page")
public Result pageTest(){
//mybatis分页插件学习
Integer pageNum = 1;
Integer pageSize = 5;
//mybatis分页插件学习
//定义分页查询信息
PageHelper pageHelper = new PageHelper();
PageHelper.startPage(pageNum, pageSize);
//第一个查询页会被分页查询
List<SysRoleDTO> selectRoleList = sysRoleMapper.selectRoleList(1);
//PageInfo类帮助整理包装分页信息，包含了很多类
PageInfo pageInfo = new PageInfo(selectRoleList);
//利用自定义PageData类接收页面所需信息，过滤掉PageInfo类中页面不需要的其他信息
PageData<SysRoleDTO> pageData = new PageData<SysRoleDTO>();
pageData.setPageNum(pageInfo.getPageNum());
pageData.setPageSize(pageInfo.getPageSize());
pageData.setPages(pageInfo.getPages());
pageData.setTotal(pageInfo.getTotal());
pageData.setList(pageInfo.getList());
return ResultUtil.success(pageData);
}
}
1667
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
