【MyBatis】篇二.MyBatis查询与特殊SQL

-代号9527

已于 2023-03-12 16:57:36 修改

阅读量529

点赞数 4

分类专栏：数据库文章标签： mybatis sql java

于 2023-03-07 17:33:58 首次发布

年轻人不要Copy------CSDN@-代号9527

本文链接：https://blog.csdn.net/llg___/article/details/129351560

版权

数据库专栏收录该内容

13 篇文章 4 订阅

订阅专栏

= = = =MyBatis整理= = = =

篇一.MyBatis环境搭建与增删改查
 篇二.MyBatis查询与特殊SQL
篇三.自定义映射resultMap和动态SQL
篇四.MyBatis缓存和逆向工程

1、MyBatis获取参数值

MyBatis获取参数值有两种方式：${} 和 #{}

${}的本质是字符串拼接
#{}的本质是占位符赋值
为字符串类型或日期类型的字段进行赋值时，拼接的${}需要手动加单引号，占位符则不用

case1-单个字面量类型的参数

当mapper接口的方法的参数是单个的字面量类型：

package com.llg.mybatis.mapper

public interface UserMapper{

	/**
	* 根据用户名获取用户信息
	*/
	User getUserByUsername(String username);
}

映射文件：

<!--User getUserByUsername(String username);-->
<select id="getUserByUsername" resultType="User">
	select * from t_user where username = #{username}
</select>

<!--User getUserByUsername(String username);-->
<select id="getUserByUsername" resultType="User">  
	select * from t_user where username = '${username}'  
</select>

当mapper接口的方法的参数是单个的字面量类型：此时可以使用${}和#{}以任意的名称（最好见名识意）获取参数的值，注意${}需要手动加单引号

在这里插入图片描述

贴个坑：
当mapper的方法参数是基础类型且只有一个时，在mapper.xml文件中使用${}取值时，会报There is no getter for property named ‘id’ in 'class java.lang.xx’异常

解决方法:

--@Param注解

public AreaDict selectById(@Param("id") Integer id);
select * from area_dict where area_dict_id = ${id}

--将${}换成#{}取值，#{}能防止sql注入，${}只是简单的字符串替换，#{}先进行预处理

select * from area_dict where area_dict_id = #{id}

--通过${value}或${_parameter}取值

select * from area_dict where area_dict_id = ${_parameter}
select * from area_dict where area_dict_id = ${value}

在这里插入图片描述

case2-多个字面量类型的参数

package com.llg.mybatis.mapper

public interface UserMapper{

	/**
	* 通过用户名和密码验证登录
	*/
	User checkLogin(String username,String password);
}

若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中，以两种方式进行存储：
。以arg0,arg1…为键，以参数为值
。以param1,param2…为键，以参数为值
通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号
使用arg或者param都行，要注意的是，arg是从arg0开始的，param是从param1开始的

<!--User checkLogin(String username,String password);-->
<select id="checkLogin" resultType="User">  
	select * from t_user where username = #{arg0} and password = #{arg1}  
</select>

<!--User checkLogin(String username,String password);-->
<select id="checkLogin" resultType="User">
	select * from t_user where username = '${param1}' and password = '${param2}'
</select>

在这里插入图片描述

case3-map集合类型的参数

参考case2的底层原理：若mapper接口方法的参数有多个时，可以手动将这些参数放在一个自己定义的map中存储，此时方法的传参类型为map集合，键名自己定义。

public interface UserMapper{

	/**
	* 验证登录（传参为map集合）
	*/
	User checkLoginByMap(Map<String,Object> map);
}

@Test
public void checkLoginByMap() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	UserMapper mapper = sqlSession.getMapper(UserrMapper.class);
	Map<String,Object> map = new HashMap<>();
	map.put("usermane","admin");
	map.put("password","admin123");
	User user = mapper.checkLoginByMap(map);
	System.out.println(user);
}

此时，获取参数值仍是通过#{}或者${}访问map集合中的键：

<!--User checkLoginByMap(Map<String,Object> map);-->
<select id="checkLoginByMap" resultType="User">
	select * from t_user where username = #{username} and password = #{password}
</select>

case3即case2的一种演变，不同的是我们手动创建了一个map集合，访问的是我们自己定义的键。

case4-实体类类型的参数

mapper接口方法的参数是实体类类型的参数：

public interface UserMapper{

	/**
	* 添加用户信息
	*/
	int insertUser(User user);
}

mapper接口中方法的参数是实体类类型，此时可用#{}或者${}，通过实体类中的属性名访问属性值。

<!--int insertUser(User user);-->
<insert id="insertUser">
	insert into t_user values(null,#{username},#{password},#{age},#{sex},#{email})
</insert>

测试：

@Test
public void testInsertUser() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	UserMapper mapper = sqlSession.getMapper(UserMapper.class);
	User user = new User(null,"llg","llg123",23,"男","llg@qq.com");
	mapper.insertUser(user);
}

case5-使用@Param注解命名参数

加入@Param注解后，MyBatis就会将这些参数放在Map集合中，以两种方式进行存储：

以@Param注解括号中的值为键，以方法的参数为值
以自己的方式来设置键名，即param1、param2。以参数为值

因此只需通过#{}和${}，以键的方式访问值即可。

public interface UserMapper{
	/**
	* 验证登录（使用@Param注解）
	*/
	User checkLoginByParam(@Param("username") String username,@Param("password") String password);
}

这是case2和3的结合，不用我们自己创建Map集合，而键名又可以自己定义。

<!--User CheckLoginByParam(@Param("username") String username, @Param("password") String password);-->
    <select id="CheckLoginByParam" resultType="User">
        select * from t_user where username = #{username} and password = #{password}
    </select>

@Test
public void checkLoginByParam() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	UserMapper mapper = sqlSession.getMapper(UserMapper.class);
	mapper.CheckLoginByParam("admin","admin123");
}

总结

以上情况可以整合为两种来处理：

实体类类型的参数
使用@Param注解标识参数

2、MyBatis的各种查询功能

如果查询出的数据只有一条，可以通过:

实体类对象接收
List集合接收
Map集合接收，结果{password=123456, sex=男, id=1, age=23, username=admin}

如果查询出的数据有多条，一定不能用实体类对象接收，会抛异TooManyResultsException，可以通过:

实体类类型的LIst集合接收
Map类型的LIst集合接收，List<Map<String,Object>>
在mapper接口的方法上添加@MapKey注解

case1-查询结果是一个实体类对象

/**
 * 根据用户id查询用户信息
 * @param id
 * @return
 */
User getUserById(@Param("id") int id);

<!--User getUserById(@Param("id") int id);-->
<select id="getUserById" resultType="User">
	select * from t_user where id = #{id}
</select>

case2-查询结果是一个List集合

/**
 * 查询所有用户信息
 * @return
 */
List<User> getUserList();

<!--List<User> getUserList();-->
<select id="getUserList" resultType="User">
	select * from t_user
</select>

case3-查询单个数据

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

注意这里的resultType，我们需要将查询结果转换为一个int，而不是User，这里使用java.lang.Integer类的别名：

<!--int getCount();-->
<select id="getCount" resultType="_integer">
	select count(*) from t_user
</select>

在MyBatis中，对于Java中常用的类型都设置了类型别名：

在这里插入图片描述

case3-查询一条数据为Map集合

当我们查询出来的数据没有任何一个实体类可以与之对应，这个时候就可以将它转换为一个Map集合，以字段为键，以字段的值为值。

/**  
 * 根据用户id查询用户信息为map集合  
 * @param id  
 * @return  
 */  
Map<String, Object> getUserToMap(@Param("id") int id);

<!--Map<String, Object> getUserToMap(@Param("id") int id);-->
<select id="getUserToMap" resultType="map">
	select * from t_user where id = #{id}
</select>
<!--结果：{password=123456, sex=男, id=1, age=23, username=admin}-->

case4-查询多条数据为Map集合

使用Map类型的List集合：

一条数据对应一个map，若有多条数据，就会产生多个map集合，此时可以将这些map放在一个list集合中获取

/**  
 * 查询所有用户信息为map集合  
 * @return   
 */  
List<Map<String, Object>> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();-->  
<select id="getAllUserToMap" resultType="map">  
	select * from t_user  
</select>
<!--
	结果：
	[{password=123456, sex=男, id=1, age=23, username=admin},
	{password=123456, sex=男, id=2, age=23, username=张三},
	{password=123456, sex=男, id=3, age=23, username=张三}]
-->

使用@MapKey注解

在mapper接口的方法上添加注解@MapKey，此时，将每条数据转换的map集合做为值，以某个字段的值做为键，放在同一个Map集合中

/**
 * 查询所有用户信息为map集合
 * @return
 * 通过@MapKey注解设置map集合的键，值是每条数据所对应的map集合
 */
@MapKey("id")
Map<String, Object> getAllUserToMap();

<!--Map<String, Object> getAllUserToMap();-->
<select id="getAllUserToMap" resultType="map">
	select * from t_user
</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=张三}
	}
-->

3、特殊SQL的执行

在执行一些特殊的SQL的时候，直接使用${}或者#{}会有问题，需要额外做一些处理：

case1-模糊查询

/**
 * 根据用户名进行模糊查询
 * @param username 
 * @return 
 */
List<User> getUserByLike(@Param("username") String username);

映射文件：

<!--List<User> getUserByLike(@Param("username") String username);-->
<select id="getUserByLike" resultType="User">
	<!--select * from t_user where username like '%${adm}%'-->  
	<!--select * from t_user where username like concat('%',#{adm},'%')-->  
	select * from t_user where username like "%"#{adm}"%"
</select>

模糊查询的SQL三种写法：

使用${}获取参数
使用concat函数拼接
直接使用双引号（最常用）select * from t_user where username like "%"#{adm}"%"

case2-批量删除

批量删除，只能使用${}，若使用#{}，SQL变为：

#{}自动加一个单引号，导致SQL语法错误：

delete from t_user where id in ('1,2,3');

正确的SQL应为：

delete from t_user where id in (1,2,3)；

delete from t_user where id in ('1','2','3')；

/**
 * 根据id批量删除
 * @param ids 
 * @return int
 */
int deleteMore(@Param("ids") String ids);

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

//测试类
@Test
public void deleteMore() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
	int result = mapper.deleteMore("1,2,3");
	System.out.println(result);
}

case3-动态设置表名

和批量删除一样，若表名使用#{}获取，则SQL语法错误，只能使用${}来实现：

/**
 * 查询指定表中的数据
 * @param tableName 
 */
List<User> getUserByTable(@Param("tableName") String tableName);

<!--List<User> getUserByTable(@Param("tableName") String tableName);-->
<select id="getUserByTable" resultType="User">
	select * from ${tableName}
</select>

case4-添加功能获取自增的主键

业务场景：
。添加班级信息
。添加学生信息
。为班级分配学生，即将某学生的班级id改为新添加的班级的id

t_class(class_id,class_name)
t_student(student_id,student_name,class_id)

//一对多的关系，关联字段加在"多"的一方

Mapper接口：

/**
 * 添加用户信息
 * @param user 
 */
void insertUser(User user);

映射文件：

<!--void insertUser(User user);-->
<insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
	insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})
</insert>

注意两个属性：

useGeneratedKeys：设置当前标签中的SQL使用了自增的主键
keyProperty：将自增的主键的值赋给传输到映射文件中参数的某个属性

(因为增删改有统一的返回值是受影响的行数，因此只能将获取的自增的主键放在传输的参数user对象的某个属性中)

//测试类
@Test
public void insertUser() {
	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
	SQLMapper mapper = sqlSession.getMapper(SQLMapper.class);
	User user = new User(null, "test2", "test123", 23, "男", "test2@qq.com");
	mapper.insertUser(user);
	System.out.println(user);
	//输出：user{id=10, username='ton', password='123', age=23, sex='男', email='123@321.com'}，自增主键存放到了user的id属性中
}