Mybatis04__输入参数/输出参数
一、输入参数源码分析
1、参数解析器解析参数(得到一个Map集合 names,默认是{arg0,arg1,arg2....},如果某一个位置使用了@Param注解,那么该位置的argx会被注解的值替代)
public ParamNameResolver(Configuration config, Method method) {
// 批量获取参数类型,我这里参数类型分别是Integer、String、String
final Class<?>[] paramTypes = method.getParameterTypes();
// 批量获取标注了@Param注解的参数,用一个二维数组封装,由于我只在id上标注了一个@Param("userId")
// 二维数组的长度与传入的参数相同,有几个参数二维数组的长度便是多少,标注了@Param注解的值用一维数组封装
// 所以最终的二维数组如下:[Annotation[1],Annotation[0],Annotation[0],]
final Annotation[][] paramAnnotations = method.getParameterAnnotations();
final SortedMap<Integer, String> map = new TreeMap<>();
// 获取二维数组的长度,由于传入了三个参数,所以长度为3
int paramCount = paramAnnotations.length;
// get names from @Param annotations
for (int paramIndex = 0; paramIndex < paramCount; paramIndex++) {
if (isSpecialParameter(paramTypes[paramIndex])) {
// skip special parameters
continue;
}
String name = null;
for (Annotation annotation : paramAnnotations[paramIndex]) {
if (annotation instanceof Param) {
hasParamAnnotation = true;
// 获取一维数组中的值,name的值为 userId
name = ((Param) annotation).value();
break;
}
}
// 如果不是使用@Param注解标注的参数,并且传入了实际参数,那么根据paramIndex的值去获取对应的值{arg0,arg1,arg2}
// 例如我们这里第二个参数使用的是 userName,那么它对应的就是 name就是arg1,第三个参数password对应的就是 arg2
if (name == null) {
// @Param was not specified.
if (config.isUseActualParamName()) {
name = getActualParamName(method, paramIndex);
}
// 这里应该是说没有实际参数传入的情况
if (name == null) {
// use the parameter index as the name ("0", "1", ...)
// gcode issue #71
name = String.valueOf(map.size());
}
}
// 这里的map就是{0:userId,1:arg1,2:arg2}
map.put(paramIndex, name);
}
// 通过Collections工具类将map转换成一个SortedMap names={0:userId,1:arg1,2:arg2}
names = Collections.unmodifiableSortedMap(map);
}
2、通过动态代理获取xxxMapper接口的代理类,然后通过invoke(...)执行目标方法,Object[] args 数组中封装的是实际传入的参数[实际参数1,实际参数2,实际参数3....]
// 动态代理执行invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (method.isDefault()) {
if (privateLookupInMethod == null) {
return invokeDefaultMethodJava8(proxy, method, args);
} else {
return invokeDefaultMethodJava9(proxy, method, args);
}
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
// 关键方法,此处的args就是实际传入的参数 Object[2,"李四","24"]
return mapperMethod.execute(sqlSession, args);
}
3、根据操作的类型来选择不同的操作方法
// 通过command.getType()方法来判断当前类型是INSERT/UPDATE/DELETE/SELECT
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
switch (command.getType()) {
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
// 返回值是否为空
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;
// 返回值是否为数组
} else if (method.returnsMany()) {
result = executeForMany(sqlSession, args);
// 是否使用@MapKey注解
} else if (method.returnsMap()) {
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
result = executeForCursor(sqlSession, args);
} else {
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
if (method.returnsOptional()
&& (result == null || !method.getReturnType().equals(result.getClass()))) {
result = Optional.ofNullable(result);
}
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}
4、将实际参数转换成Sql命令参数
public Object convertArgsToSqlCommandParam(Object[] args) {
return paramNameResolver.getNamedParams(args);
}
5、获取最终的参数集合
public Object getNamedParams(Object[] args) {
// 这里面的names就是我们通过参数解析器获得的SortedMap names={0:userId,1:arg1,2:arg2}
// 此处的args就是实际传入的参数 args = Object[2,"李四","24"]
final int paramCount = names.size();
// 如果没有传入实际参数,或者参数的名称个数为0,直接返回null
if (args == null || paramCount == 0) {
return null;
// 如果没有使用@Parma注解并且只有一个参数,那么直接返回第一个参数
} else if (!hasParamAnnotation && paramCount == 1) {
return args[names.firstKey()];
} else {
final Map<String, Object> param = new ParamMap<>();
int i = 0;
// names={0:userId,1:arg1,2:arg2} args = Object[2,"李四","24"]
// 遍历names,并且将相应的数据存入Map集合param中,存入的规则如下
// param = {userId:2,arg1:"李四",arg2:"24"}
for (Map.Entry<Integer, String> entry : names.entrySet()) {
param.put(entry.getValue(), args[entry.getKey()]);
// GENERIC_NAME_PREFIX的值为常量 param
final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
// 如果names中不包含param1、param2...等等数据,那么集合param中继续存入一份数据
// {param1:2,param2:"李四",param3:"24"}
if (!names.containsValue(genericParamName)) {
param.put(genericParamName, args[entry.getKey()]);
}
i++;
}
// 最终的Map集合 param={userId:2,arg1:"李四",arg2:"24",param1:2,param2:"李四",param3:"24"}
// 相当于是对传入的参数使用了两套保存机制
return param;
}
}
}
二、实际案例结合上述源码
1、UserMapper接口
public interface UserMapper {
// 根据id、userName、password三个条件查询用户信息
public abstract User queryUserByThreeConditions(@Param("userId") Integer id, String userName, String password);
}
2、UserMapper.xml
根据下面的源码分析,可以得出如下结论,当传入多个参数的时候,如果没有使用@Param注解对参数进行标注,那么param={arg0:2,arg1:"李四",arg2:"24",param1:2,param2:"李四",param3:"24"},如果某个参数使用了@Param注解的话,那么对应的位置的 argx 就会被@Param("value")中的value值所替代,
所以我们这个例子中param={userId:2,arg1:"李四",arg2:"24",param1:2,param2:"李四",param3:"24"},只要能确保传入的最终参数是{2,"李四","24"},你可以使用各种各样的方式去param这个集合中取取值,例如下面的几种方式都是可以的
<!--根据id、userName、password三个条件查询用户信息-->
<select id="queryUserByThreeConditions" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{param1} AND USER_NAME=#{param2} AND PASSWORD=#{param3}
</select>
<select id="queryUserByThreeConditions" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{userId} AND USER_NAME=#{arg1} AND PASSWORD=#{arg2}
</select>
<select id="queryUserByThreeConditions" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{userId} AND USER_NAME=#{param2} AND PASSWORD=#{param3}
</select>
<select id="queryUserByThreeConditions" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{param1} AND USER_NAME=#{arg1} AND PASSWORD=#{arg2}
</select>
3、测试类
public class TestMybatis {
@Test
public void test01() throws IOException {
SqlSession session = TestMybatis.openSession();
UserMapper mapper = session.getMapper(UserMapper.class);
User user = mapper.queryUserByThreeConditions(2, "李四", "24");
System.out.println(user);
}
}
三、输入参数
1、单个参数
01、传入基本类型数据
<!--根据主键ID查询用户信息-->
// UserMapper接口
public abstract User queryUserById(Integer id);
// UserMapper.xml
<select id="queryUserById" resultType="com.mybatis.entity.User">
// 取值的时候可以使用#{任意字符}获得传入的参数
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user WHERE ID=#{xxx}
</select>
02、传入POJO类型
<!--根据id和userName查询用户信息-->
// UserMapper接口
public abstract User queryUserByIdAnduserName(User user);
// UserMapper.xml
<select id="queryUserByIdAnduserName" resultType="com.mybatis.entity.User">
// 对于传入的是POJO类型的参数,取值的时候需要使用#{POJO的属性名}来取值
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{id} AND USER_NAME=#{userName}
</select>
2、多个参数(这种情况下可以配合@Param("value")注解,可以做到见名知意)
<!--根据id、userName、password三个条件查询用户信息-->
<select id="queryUserByThreeConditions" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{param1} AND USER_NAME=#{param2} AND PASSWORD=#{param3}
</select>
<select id="queryUserByThreeConditions" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{userId} AND USER_NAME=#{arg1} AND PASSWORD=#{arg2}
</select>
<select id="queryUserByThreeConditions" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{userId} AND USER_NAME=#{param2} AND PASSWORD=#{param3}
</select>
<select id="queryUserByThreeConditions" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{param1} AND USER_NAME=#{arg1} AND PASSWORD=#{arg2}
</select>
3、传入Map集合
传入Map集合(mybatis本来就是要把输入的参数转化为map存起来,既然你已经传入了一个map集合,直接通过键取值就可以了)
map:{"id":1,"password":23}
public abstract User queryUserByIdAndPassword(Map<String,Object> map);
// 这里的id、password对应的是传入进来的Map集合的key
<select id="queryUserByIdAndPassword" resultType="com.mybatis.entity.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM user
WHERE ID=#{id} AND PASSWORD=#{password}
</select>
4、传入Integer类型数组
//根据多个用户id查询出多条用户记录
public abstract List<User> queryUsersByIds(Integer[] ids);
<!--根据多个用户id查询出多条用户记录-->
<select id="queryUsersByIds" resultType="com.mybatis.domain.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM tbl_user
<where>
ID in
<foreach collection="array" item="id" open="(" close=")" separator=",">
#{id}
</foreach>
</where>
</select>
5、传入List集合
//根据多个用户id查询出多条用户记录
public abstract List<User> queryUsersByIds(List<Integer> ids);
<!--根据多个用户id查询出多条用户记录-->
<select id="queryUsersByIds" resultType="com.mybatis.domain.User">
SELECT ID,USER_NAME,PASSWORD,USER_INFORMATION FROM tbl_user
<where>
ID in
<foreach collection="list" item="id" open="(" close=")" separator=",">
#{id}
</foreach>
</where>
</select>
四、输出参数
1、resultType,返回值类型为实体类对象:自动封装,将数据库中的数据自动封装到javaBean中
// 根据用户EmployeeId查询用户信息
public abstract Employee queryEmployeeByEmployeeId(Employee employee);
<select id="queryEmployeeByEmployeeId" resultType="com.mybatis.entity.Employee">
SELECT
e.EMPLOYEE_ID,
e.EMPLOYEE_NAME,
e.EMPLOYEE_PASSWORD,
e.EMPLOYEE_AGE,
e.DEPARTMENT_ID
FROM
employee e
WHERE
e.EMPLOYEE_ID=#{employeeId}
</select>
// 测试结果
Employee{employeeId=3, employeeName='王五', employeePassword='789', employeeAge='25', departmentId=3}
2、resultType,返回值类型为map
// 根据用户EmployeeId查询用户信息
public abstract Map<String,Object> queryEmployeeByEmployeeId(Employee employee);
<select id="queryEmployeeByEmployeeId" resultType="java.util.Map">
SELECT
e.EMPLOYEE_ID,
e.EMPLOYEE_NAME,
e.EMPLOYEE_PASSWORD,
e.EMPLOYEE_AGE,
e.DEPARTMENT_ID
FROM
employee e
WHERE
e.EMPLOYEE_ID=#{employeeId}
</select>
// 测试结果
{EMPLOYEE_ID=3, EMPLOYEE_AGE=25, DEPARTMENT_ID=3, EMPLOYEE_NAME=王五, EMPLOYEE_PASSWORD=789}
3、如果查询的结果是多条记录,而又指定返回值为map集合,这个时候就不能使用mybatis的自动封装,这个时候要为多条记录指定主键,使用@MapKey("数据库中的列名")
// EMPLOYEE_ID对应的是数据库的字段
@MapKey("EMPLOYEE_ID")
public abstract Map<String,Object> queryEmployeeByEmployeeId(Employee employee);
// 根据employeeAge模糊查询用户信息
<select id="queryEmployeeByEmployeeId" resultType="java.util.Map">
SELECT
e.EMPLOYEE_ID,
e.EMPLOYEE_NAME,
e.EMPLOYEE_PASSWORD,
e.EMPLOYEE_AGE,
e.DEPARTMENT_ID
FROM
employee e
WHERE
e.EMPLOYEE_AGE
LIKE
"%"#{employeeAge}"%"
</select>
// 测试结果
{
1={EMPLOYEE_ID=1, EMPLOYEE_AGE=23, DEPARTMENT_ID=1, EMPLOYEE_NAME=张三, EMPLOYEE_PASSWORD=123},
2={EMPLOYEE_ID=2, EMPLOYEE_AGE=24, DEPARTMENT_ID=2, EMPLOYEE_NAME=李四, EMPLOYEE_PASSWORD=456},
3={EMPLOYEE_ID=3, EMPLOYEE_AGE=25, DEPARTMENT_ID=3, EMPLOYEE_NAME=王五, EMPLOYEE_PASSWORD=789},
4={EMPLOYEE_ID=4, EMPLOYEE_AGE=26, DEPARTMENT_ID=4, EMPLOYEE_NAME=赵六, EMPLOYEE_PASSWORD=1123},
5={EMPLOYEE_ID=5, EMPLOYEE_AGE=27, DEPARTMENT_ID=1, EMPLOYEE_NAME=田七, EMPLOYEE_PASSWORD=123579}
}
4、返回值类型为resultMap:支持手动的封装(多对一)
// 实体类Employee,省略set/get/toString方法
public class Employee {
private Integer employeeId;
private String employeeName;
private String employeePassword;
private String employeeAge;
private Department department;
}
// 实体类Department,省略set/get/toString方法
public class Department {
private Integer departmentId;
private String description;
private String location;
}
// EmployeeMapper接口
public interface EmployeeMapper {
// 根据用户EmployeeId查询用户信息
public abstract Employee queryEmployeeByEmployeeId(Integer id);
}
// EmployeeMapper的全包类路径
<mapper namespace="com.mybatis.dao.EmployeeMapper">
// 这里的emp可以是任意值,但是一定要和resultMap的值相同
<resultMap id="emp" type="com.mybatis.entity.Employee">
// 主键策略
<id property="employeeId" column="EMPLOYEE_ID" javaType="int" jdbcType="INTEGER"></id>
<result property="employeeName" column="EMPLOYEE_NAME" javaType="string" jdbcType="VARCHAR"></result>
<result property="employeePassword" column="EMPLOYEE_PASSWORD" javaType="string" jdbcType="VARCHAR"></result>
<result property="employeeAge" column="EMPLOYEE_AGE" javaType="string" jdbcType="VARCHAR"></result>
// 由于Employee实体类中有Department属性,这里的department对应的是属性名,javaType对应Department实体类的全包类路径
<association property="department" javaType="com.mybatis.entity.Department">
// 主键策略
<id property="departmentId" column="DEPARTMENT_ID" javaType="int" jdbcType="INTEGER"></id>
<result property="description" column="DESCRIPTION" javaType="string" jdbcType="VARCHAR"></result>
<result property="location" column="LOCATION" javaType="string" jdbcType="VARCHAR"></result>
</association>
</resultMap>
<select id="queryEmployeeByEmployeeId" resultMap="emp">
SELECT
e.EMPLOYEE_ID,
e.EMPLOYEE_NAME,
e.EMPLOYEE_PASSWORD,
e.EMPLOYEE_AGE,
d.DEPARTMENT_ID,
d.DESCRIPTION,
d.LOCATION
FROM employee e
LEFT JOIN
department d
ON
e.DEPARTMENT_ID=D.DEPARTMENT_ID
WHERE e. EMPLOYEE_ID=#{employeeId}
</select>
</mapper>
// 测试结果
Employee{
employeeId=1,
employeeName='张三',
employeePassword='123',
employeeAge='23',
department=Department{departmentId=1, description='市场部', location='北京'}
}
5、返回值类型为resultMap:支持手动的封装(一对多)
// 实体类Employee,省略set/get/toString方法
public class Employee {
private Integer employeeId;
private String employeeName;
private String employeePassword;
private String employeeAge;
private Integer departmentId;
}
// 实体类Department,省略set/get/toString方法
public class Department {
private Integer departmentId;
private String description;
private String location;
private List<Employee> employees;
}
// 查询部门编号为1的所有所有员工信息
public abstract Department queryAllByDepartmentId(Integer id);
<mapper namespace="com.mybatis.dao.DepartmentMapper">
// dep任意,但是一定要和resultMap的值相同
<resultMap id="dep" type="com.mybatis.entity.Department">
<id property="departmentId" column="DEPARTMENT_ID" javaType="int" jdbcType="INTEGER"></id>
<result property="description" column="DESCRIPTION" javaType="string" jdbcType="VARCHAR"></result>
<result property="location" column="LOCATION" javaType="string" jdbcType="VARCHAR"></result>
// Department中有一个List<Employee>集合,使用ofType引入Employee对象
<collection property="employees" ofType="com.mybatis.entity.Employee">
<id property="employeeId" column="EMPLOYEE_ID" javaType="int" jdbcType="INTEGER"></id>
<result property="employeeName" column="EMPLOYEE_NAME" javaType="string" jdbcType="VARCHAR"></result>
<result property="employeePassword" column="EMPLOYEE_PASSWORD" javaType="string" jdbcType="VARCHAR"></result>
<result property="employeeAge" column="EMPLOYEE_AGE" javaType="string" jdbcType="VARCHAR"></result>
<result property="departmentId" column="DEPARTMENT_ID" javaType="int" jdbcType="INTEGER"></result>
</collection>
</resultMap>
<select id="queryAllByDepartmentId" resultMap="dep">
SELECT
d.DEPARTMENT_ID,
d.DESCRIPTION,
d.LOCATION,
e.EMPLOYEE_ID,
e.EMPLOYEE_NAME,
e.EMPLOYEE_PASSWORD,
e.EMPLOYEE_AGE
FROM department d
LEFT JOIN
employee e
ON
d.DEPARTMENT_ID=e.DEPARTMENT_ID
WHERE d.DEPARTMENT_ID=#{departmentId}
</select>
</mapper>
// 测试结果
Department{
departmentId=1,
description='市场部',
location='北京',
employees=
[
Employee{employeeId=1, employeeName='张三', employeePassword='123', employeeAge='23', departmentId=1},
Employee{employeeId=5, employeeName='田七', employeePassword='123579', employeeAge='27', departmentId=1}
]
}
