03-MyBatis（二）

m0_73676663

已于 2023-02-19 19:14:31 修改

阅读量56

点赞数

分类专栏： Java框架文章标签： mybatis java 数据库

于 2023-02-19 19:10:59 首次发布

本文链接：https://blog.csdn.net/m0_73676663/article/details/129113384

版权

Java框架专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

5、MyBatis获取参数值的两种方式
6、MyBatis的各种查询功能
7、特殊SQL的执行
8、自定义映射resultMap

5、MyBatis获取参数值的两种方式

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

${}的本质就是字符串拼接，#{}的本质就是占位符赋值

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

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

5.1、单个字面量类型的参数

若mapper接口中的方法参数为单个的字面量类型

此时可以使用${}和#{}以任意的内容获取参数的值，但建议与参数名保持一致。注意${}需要手动加单引号

字符串、基本数据类型及其包装类都属于字面量类型

public interface UserMapper {
    //根据用户名查询用户信息
    User getUserByUsername(String username);
}

<mapper namespace="com.atguigu.day02mybatis_parameter.mapper.UserMapper">
    <!--User getUserByUsername(String username);-->
    <select id="getUserByUsername" resultType="User">
        <!--select * from t_user where username='${username}';-->
        <!--select * from t_user where username=#{name};-->
        select * from t_user where username=#{username};
    </select>
</mapper>

public class ParameterTest {
    @Test
    public void testGetUserByUsername(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserByUsername("admin");
        System.out.println(user);
    }
}

5.2、多个字面量类型的参数

若mapper接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个map集合中，以两种方式存储数据：

以arg0、arg1…为键，以参数为值；
或者以param1、param2…为键，以参数为值；

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

public interface UserMapper {
    //验证登录
    User checkLogin(String username,String password);
}

<mapper namespace="com.atguigu.day02mybatis_parameter.mapper.UserMapper">
    <!--User checkLogin(String username,String password);-->
    <select id="checkLogin" resultType="User">
        <!--select * from t_user where username='${param1}' and password='${param2}';-->
        <!--select * from t_user where username=#{arg0} and password=#{arg1};-->
        select * from t_user where username=#{param1} and password=#{param2};
    </select>
</mapper>

5.3、map集合类型的参数

若mapper接口中的方法需要的参数为多个时，此时可以手动创建map集合，将这些数据放在map中

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

public interface UserMapper {
    //验证登录（以map集合作为参数）
    User checkLoginByMap(Map<String,Object> map);
}

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

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

5.4、实体类类型的参数

若mapper接口中的方法参数为实体类对象时

此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值，注意${}需要手动加单引号

public interface UserMapper {
    //添加用户信息
    void insertUser(User user);
}

<mapper namespace="com.atguigu.day02mybatis_parameter.mapper.UserMapper">
    <!--void insertUser(User user);-->
    <insert id="insertUser">
        insert into t_user values(null,#{username},#{password},#{age},#{gender},#{email});
    </insert>
</mapper>

public class ParameterTest {
    @Test
    public void testInsertUser(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user=new User(null,"root","123456",33,"女","123@qq.com");
        mapper.insertUser(user);
    }
}

5.5、使用@Param标识参数

可以通过@Param注解标识mapper接口中的方法参数，此时，会将这些参数放在map集合中，以两种方式进行存储：

以@Param注解的value属性值为键，以参数为值；
以param1、param2…为键，以参数为值；

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

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

<mapper namespace="com.atguigu.day02mybatis_parameter.mapper.UserMapper">
    <!--User checkLoginByParam(@Param("username") String username, @Param("password") String password);-->
    <select id="checkLoginByParam" resultType="User">
        <!--select * from t_user where username=#{param1} and password=#{param2};-->
        select * from t_user where username=#{username} and password=#{password};
    </select>
</mapper>

public class ParameterTest {
    @Test
    public void testCheckLoginByParam(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.checkLoginByParam("admin", "123456");
        System.out.println(user);
    }
}

6、MyBatis的各种查询功能

6.1、查询一个实体类对象

/**
* 根据用户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>

6.2、查询一个list集合

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

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

当查询的数据为多条时，一定不能使用实体类作为返回值，否则会抛出异常TooManyResultsException；

但是若查询的结果只有一条，可以使用实体类也可使用集合作为返回值

6.3、查询单个数据

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

<!--int getCount();-->
<!--<select id="getCount" resultType="java.lang.Integer">-->
<select id="getCount" resultType="integer">
	select count(id) from t_user
</select>

6.4、查询一条数据为map集合

/**
* 根据用户id查询用户信息为map集合
* 若查询结果中某个字段的值为null，则该字段不会放入map集合中
* @param id
* @return
*/
Map<String, Object> getUserToMap(@Param("id") int id);

<!--Map<String, Object> getUserByIdToMap(@Param("id") int id);-->
<select id="getUserByIdToMap" resultType="map">
	select * from t_user where id = #{id}
</select>

public class SelectMapperTest {
    @Test
    public void testGetUserByIdToMap(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        Map<String, Object> map = mapper.getUserByIdToMap(2);
        System.out.println(map);
        //{password=123456, gender=男, id=2, age=23, email=12345@qq.com, username=admin}
    }
}

6.5、查询多条数据为map集合

①方式一

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

<!--Map<String, Object> getAllUserToMap();-->
<select id="getAllUserToMap" resultType="map">
	select * from t_user
</select>

②方式二

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

<!--Map<String, Object> getAllUserToMap();-->
<select id="getAllUserToMap" resultType="map">
	select * from t_user
</select>

public class SelectMapperTest {
    @Test
    public void testGetAllUserToMap(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        /*List<Map<String, Object>> list = mapper.getAllUserToMap();
        System.out.println(list);*/
        Map<String, Object> map = mapper.getAllUserToMap();
        System.out.println(map);
        //{2={password=123456, gender=男, id=2, age=23, email=12345@qq.com, username=admin},
        // 3={password=123456, gender=女, id=3, age=33, email=123@qq.com, username=root}}
    }
}

7、特殊SQL的执行

7.1、模糊查询

/**
* 通过用户名模糊查询用户信息
* @param mohu
* @return
*/
List<User> getUserByLike(@Param("mohu") String mohu);

<!--List<User> getUserByLike(@Param("mohu") String mohu);-->
<select id="getUserByLike" resultType="User">
    <!--select * from t_user where username like '%#{mohu}%';//error-->
    <!--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>

7.2、批量删除

/**
* 批量删除
* @param ids
* @return
*/
int deleteMoreUser(@Param("ids") String ids);

<!--int deleteMoreUser(@Param("ids") String ids);-->
<delete id="deleteMoreUser">
    <!--delete from t_user where id in(#{ids});//error-->
	delete from t_user where id in (${ids});
</delete>

7.3、动态设置表名

/**
* 动态设置表名，查询所有的用户信息
* @param tableName
* @return
*/
List<User> getUserList(@Param("tableName") String tableName);

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

7.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);

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

8、自定义映射resultMap

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

若字段名和实体类中的属性名不一致，则可以通过resultMap设置自定义映射

<!--
    resultMap：设置自定义的映射关系
    属性：
    id：表示自定义映射的唯一标识
    type：查询的数据要映射的实体类的类型
    常用的子标签：
    id：设置主键和实体类中属性的映射关系
    result：设置普通字段和实体类中属性的映射关系
    子标签属性：
    property：设置映射关系中实体类中的属性名
    column：设置映射关系中表中的字段名，必须是sql查询出的某个字段
-->
<mapper namespace="com.atguigu.day03mybatis_resultMap.mapper.EmpMapper">
    <resultMap id="empResultMap" type="Emp">
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
        <result column="dept_id" property="deptId"></result>
    </resultMap>

    <!--Emp getEmpByEmpId(@Param("empId") Integer empId);-->
    <select id="getEmpByEmpId" resultMap="empResultMap">
        <!--select emp_id empId,emp_name empName,age,gender from t_emp where emp_id=#{empId};-->
        select * from t_emp where emp_id=#{empId};
    </select>
</mapper>

public interface EmpMapper {
    //根据id查询员工信息
    Emp getEmpByEmpId(@Param("empId") Integer empId);
}

实体类：

public class Emp {
    private Integer empId;
    private String empName;
    private Integer age;
    private String gender;
    private Dept dept;

    //构造方法、GetTer/Setter方法、toString方法在此省略
}

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

的规则（使用驼峰，此时也可通过以下两种方式处理字段名和实体类中的属性的映射关系：

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

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

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

射为empId

<!--Emp getEmpByEmpId(@Param("empId") Integer empId);-->
<select id="getEmpByEmpId" resultType="Emp">
    <!--select emp_id empId,emp_name empName,age,gender from t_emp where emp_id=#{empId};-->
    select * from t_emp where emp_id=#{empId};
</select>

mybatis核心配置文件中设置如下：（注意其位置和顺序）

<settings>
    <!--将下划线映射为驼峰-->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

8.2、多对一映射处理

场景模拟：

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

8.2.1、级联方式处理映射关系

//获取员工以及所对应的部门信息
Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);

<resultMap id="empAndDeptResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="gender" property="gender"></result>
    <result column="dept_id" property="dept.deptId"></result>
    <result column="dept_name" property="dept.deptName"></result>
</resultMap>

<!--Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);-->
<select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMap">
    select t_emp.*,t_dept.*
    from t_emp left join t_dept on t_emp.dept_id=t_dept.dept_id
    where t_emp.emp_id=#{empId};
</select>

8.2.2、使用association处理映射关系

<!--
	association标签：设置多对一的映射关系（处理实体类类型的属性）
	javaType属性：设置要处理的属性的类型
-->

<resultMap id="empAndDeptResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="gender" property="gender"></result>
    <association property="dept" javaType="Dept">
        <id column="dept_id" property="deptId"></id>
        <result column="dept_name" property="deptName"></result>
    </association>
</resultMap>

<!--Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);-->
<select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMap">
    select t_emp.*,t_dept.*
    from t_emp left join t_dept on t_emp.dept_id=t_dept.dept_id
    where t_emp.emp_id=#{empId};
</select>

8.2.3、分步查询

①查询员工信息

public interface EmpMapper {
    //通过分步查询来查询员工以及所对应的部门信息的第一步
    Emp getEmpAndDeptByStepOne(@Param("empId") Integer empId);
}

<resultMap id="empAndDeptByStepResultMap" type="Emp">
    <id column="emp_id" property="empId"></id>
    <result column="emp_name" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="gender" property="gender"></result>
    <!--
		property：设置需要处理映射关系的属性的属性名
        select：设置分步查询，查询某个属性的值的sql的唯一标识（namespace.sqlId）
        column：将sql以及查询结果中的某个字段设置为分步查询的sql的条件
		fetchType：在开启了延迟加载的环境中，通过该属性设置当前的分布查询是狗使用延迟加载
	-->
    <association property="dept" fetchType="eager"
                 select="com.atguigu.day03mybatis_resultMap.mapper.
                         DeptMapper.getEmpAndDeptByStepTwo"
                 column="dept_id"></association>
</resultMap>

<!--Emp getEmpAndDeptByStepOne(@Param("empId") Integer empId);-->
<select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
    select * from t_emp where emp_id=#{empId};
</select>

②根据员工所对应的部门id查询部门信息

public interface DeptMapper {
    //通过分步查询来查询员工以及所对应的部门信息的第二步
    Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);
}

<!--Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);-->
<select id="getEmpAndDeptByStepTwo" resultType="Dept">
    select * from t_dept where dept_id=#{deptId};
</select>

8.3、一对多映射处理

8.3.1、collection

public class Dept {
    private Integer deptId;
    private String deptName;
    private List<Emp> emps;

    //构造方法、GetTer/Setter方法、toString方法在此省略
}

public interface DeptMapper {
    //查询部门以及部门中的员工信息
    Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId);
}

<resultMap id="deptAndEmpResultMap" type="Dept">
    <id column="dept_id" property="deptId"></id>
    <result column="dept_name" property="deptName"></result>
    <!--
		collection标签：设置一对多的映射关系（处理集合类型的属性）
		ofType属性：设置collection标签所处理的集合类型的属性中存储数据的类型
	-->
    <collection property="emps" ofType="Emp">
        <id column="emp_id" property="empId"></id>
        <result column="emp_name" property="empName"></result>
        <result column="age" property="age"></result>
        <result column="gender" property="gender"></result>
    </collection>
</resultMap>

<!--Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpByDeptId" resultMap="deptAndEmpResultMap">
    select *
    from t_dept left join t_emp on t_dept.dept_id=t_emp.dept_id
    where t_dept.dept_id=#{deptId};
</select>

8.3.2、分步查询

①查询部门信息

//通过分步查询来查询部门以及部门中的员工信息的第一步
Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);

<resultMap id="deptAndEmpResultMapByStep" type="Dept">
    <id column="dept_id" property="deptId"></id>
    <result column="dept_name" property="deptName"></result>
    <collection property="emps" fetchType="eager"
                select="com.atguigu.day03mybatis_resultMap.mapper.
                        EmpMapper.getDeptAndEmpByStepTwo"
                column="dept_id"></collection>
</resultMap>

<!--Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpResultMapByStep">
    select * from t_dept where dept_id=#{deptId};
</select>

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

public interface EmpMapper {
    //通过分步查询来查询部门以及部门中的员工信息的第二步
    List<Emp> getDeptAndEmpByStepTwo(@Param("deptId") Integer deptId);
}

<!--List<Emp> getDeptAndEmpByStepTwo(@Param("deptId") Integer deptId);-->
<select id="getDeptAndEmpByStepTwo" resultType="Emp">
    select * from t_emp where dept_id=#{deptId};
</select>

分步查询的优点：可以实现延迟加载

但是必须在核心配置文件中设置全局配置信息：

lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载

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

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。

此时可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载：

fetchType=“lazy”（延迟加载）
fetchType=“eager”（立即加载）

<settings>
    <!--开启延迟加载-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!--按需加载，默认值为false-->
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

m0_73676663

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
03-MyBatis（二）

Mybatis学习笔记二，参考视频：【【尚硅谷】SSM框架全套教程，MyBatis+Spring+SpringMVC+SSM整合一套通关】https://www.bilibili.com/video/BV1Ya411S7aT/?p=63&share_source=copy_web&vd_source=19f3a5f9956dd56dae66f9323766a58d
复制链接

扫一扫