【Mybatis学习笔记二】

根据尚硅谷SSM教程的老师的笔记加上自己的一些修改做的笔记

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

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

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

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

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

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

此时可以使用${}和#{}以任意的名称获取参数的值，注意

${}需要手动加单引号
例如：

<mapper namespace="com.atguigu.mybatis.mapper.UserMapper">

    <select id="getUserByUsername" resultType="User">
        select * from t_user where username = #{username}
        select * from t_user where username = '${username}'
    </select>
</mapper>

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

若mapper接口中的方法参数为多个时此时MyBatis会自动将这些参数放在一个map集合中，以arg0,arg1…为键，以参数为值；以param1,param2…为键，以参数为值；
因此只需要通过￥{}和#{}访问map集合的键就可以获取相对应的值，注意需要手动加单引号($无法显示，用￥代替)

    <select id="checkLogin" resultType="User">
        select * from t_user where username = #{arg0} and password = #{arg1}
        select * from t_user where username = '${param1}' and password = '${param2}'
    </select>

5.3、map集合类型的参数

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

测试：
 @Test
    public void testCheckLoginByMap(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        Map<String,Object> map = new HashMap<>();
        map.put("username","root");
        map.put("password","123");
        User user = mapper.checkLoginByMap(map);
        System.out.println(user);
    }
    xml文件中：
    <select id="checkLoginByMap" resultType="User">
        select * from t_user where username = #{username} and password = #{password}
    </select>

5.4、实体类类型的参数

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

此时可以使用${}和#{}，通过访问实体类对象中的属性名获取属性值，注意

${}需要手动加单引号
属性只跟get、set方法有关。

接口中：
    void InsertUser(User user);
.xml文件中
    <insert id="InsertUser" >
        insert into t_user values(null,#{username},#{password},#{age},#{gender},#{email})
    </insert>
测试中：
    @Test
    public void testInsertUser(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = new User(null,"hjx","1234",23,"男","hjx@qq.com");
        mapper.InsertUser(user);
    }

5.5、使用@Param标识参数

可以通过@Param注解标识mapper接口中的方法参数

此时，会将这些参数放在map集合中，以@Param注解value属性值为键，以参数为值；以
param1,param2…为键，以参数为值；只需要通过${}和#{}访问map集合的键就可以获取相对应的值，

注意${}需要手动加单引号

接口中：
   User checkLoginByParam(@Param("username") String username, @Param("password") String password);
.xml文件中
    <select id="checkLoginByParam" resultType="User">
        select * from t_user where username = #{username} and password = #{password}
    </select>
测试中：
       @Test
    public void testcheckLoginByParam(){
        SqlSession sqlSession = SqlSessionUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.checkLoginByParam("hjx", "1234");
        System.out.println(user);
    }
    }

# 6、MyBatis的各种查询功能

## 6.1、查询一个实体类对象

/**

• 根据用户id查询用户信息
• @param id
• @return
  */
  接口：
  User getUserById(@Param(“id”) int id);
  .xml文件

select * from t_user where id = #{id} ```

6.2、查询一个list集合

/**
* 查询所有用户信息
* @return
*/
接口：
List<User> getUserList();
.xml文件
<!--List<User> getUserList();-->
<select id="getUserList" resultType="User">
	select * from t_user
</select>

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

TooManyResultsException；但是若查询的数据只有一条，可以使用实体类或集合作为返回值

6.3、查询单个数据

/**
* 查询用户的总记录数
* @return
* 在MyBatis中，对于Java中常用的类型都设置了类型别名
* 例如： java.lang.Integer-->int|integer
* 例如： int-->_int|_integer
* 例如： Map-->map,List-->list
*/
接口：
int getCount();
.xml文件
<!--int getCount();-->
<select id="getCount" resultType="_integer">
	select count(id) from t_user
</select>

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

/**
* 根据用户id查询用户信息为map集合
* @param id
* @return
*/
接口：
Map<String, Object> getUserToMap(@Param("id") int id);
.xml文件：
<!--Map<String, Object> getUserToMap(@Param("id") int id);-->
<!--结果： {password=123456, sex=男 , id=1, age=23, username=admin}-->
<select id="getUserToMap" resultType="map">
	select * from t_user where id = #{id}
</select>

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

①方式一

/**
* 查询所有用户信息为map集合
* @return
* 将表中的数据以map集合的方式查询，一条数据对应一个map；若有多条数据，就会产生多个map集合，此
时可以将这些map放在一个list集合中获取
*/
接口：
List<Map<String, Object>> getAllUserToMap();
.xml文件：
<!--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();-->
<!--
{
    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=张三}
}
-->
.xml文件
<select id="getAllUserToMap" resultType="map">
	select * from t_user
</select>

7、特殊SQL的执行

7.1、模糊查询

/**
* 测试模糊查询
* @param mohu
* @return
*/
List<User> testMohu(@Param("mohu") String mohu);
<!--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>

7.2、批量删除

/**
* 批量删除
* @param ids
* @return
*/
int deleteMore(@Param("ids") String ids);
<!--int deleteMore(@Param("ids") String ids);-->
<delete id="deleteMore">
	delete from t_user where id in (${ids})
</delete>

7.3、动态设置表名

/**
* 动态设置表名，查询所有的用户信息
* @param tableName
* @return
*/
List<User> getAllUser(@Param("tableName") String tableName);
<!--List<User> getAllUser(@Param("tableName") String tableName);-->
<select id="getAllUser" resultType="User">
	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},#{sex})
</insert>

8、自定义映射resultMap

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

搭建mapper框架

1.新建Maven项目，配置pom.xml （可用项目1的pom.xml内容）

2.z在main/Resurces下创建mybatis-config核心配置文件

3.在main/java下创建包com.atguigu.mybatis.pojo

4.在main/java下创建包com.atguigu.mybatis.mapper

5.在main/Resurces下创建com/atguigu/mybatis/mapper存放对应.xml映射文件

6.配置cofig文件

取别名，默认问类名
<typeAliases>

        <package name="com.atguigu.mybatis.pojo"/>
    </typeAliases>
<!--引入映射文件-->
    <mappers>
        <!--<mapper resource="mappers/UserMapper.xml"/>-->
        <!--
            以包为单位引入映射文件
               要求：
               1、mapper接口所在的包要和映射文件所在的包一致
               2、mapper接口要和映射文件的名字一致
               <package name="com.atguigu.mybatis.mapper"/>

          -->
        <package name="com.atguigu.mybatis.mapper"/>
    </mappers>

7.创建数据表t_emp
8.创建数据表t_dept
9.创建JavaBean

public class Emp {
    private Integer eid;
    private String empName;
    private Integer age;
    private String sex;
    private String email;
    private Dept dept;}

public class Dept {
    private Integer did;
    
    private String deptName;
}

10.创建mapper接口
11.创建映射文件

![在这里插入图片描述](https://img-blog.csdnimg.cn/491cbac2bd984dfcbda9221bd061dd65.png#pic_center

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

<!--    设置mybatis的全局配置-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

<!--
    resultMap：设置自定义映射
    属性：
    id：表示自定义映射的唯一标识
    type：查询的数据要映射的实体类的类型
    子标签：
    id：设置主键的映射关系
    result：设置普通字段的映射关系
    association：设置多对一的映射关系(实体类类型的属性
    collection：设置一对多的映射关系（集合类型的属性
    属性：
    property：设置映射关系中实体类中的属性名
    column：设置映射关系中表中的字段名
        <resultMap id="empResultMap" type="Emp">
        <!--        id设置主键-->
        <id property="eid" column="eid"></id>
        <!--        result设置普通字段-->
        <result property="empName" column="emp_name"></result>
        <result property="age" column="age"></result>
        <result property="sex" column="sex"></result>
        <result property="email" column="email"></result>
    </resultMap>
    <select id="getAllEmp" resultMap="empResultMap">
        select * from t_emp
    </select>
-->

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

名符合Java的规则（使用驼峰）

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

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

b>可以在MyBatis的核心配置文件中设置一个全局配置信息mapUnderscoreToCamelCase，可

以在查询表中数据时，自动将_类型的字段名转换为驼峰

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

userName

8.2、多对一映射处理

场景模拟：

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

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

<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="dept_name" property="dept.deptName"></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>

8.2.2、使用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="dept_name" property="deptName"></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>

8.2.3、分步查询

①查询员工信息

/**
* 通过分步查询查询员工信息
* @param eid
* @return
*/
Emp getEmpByStep(@Param("eid") int eid);
<resultMap id="empDeptStepMap" type="Emp">
    <id column="eid" property="eid"></id>
    <result column="emp_ame" property="empName"></result>
    <result column="age" property="age"></result>
    <result column="sex" property="sex"></result>
	<!--
        select：设置分步查询，查询某个属性的值的sql的标识（mapper接口全类名.方法名）
        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>

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

/**
* 分步查询的第二步： 根据员工所对应的did查询部门信息
* @param did
* @return
*/
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>

8.3、一对多映射处理

8.3.1、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>

8.3.2、分步查询

①查询部门信息

/**
* 分步查询部门和部门中的员工
* @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>

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

/**
* 根据部门id查询员工信息
* @param did
* @return
*/
List<Emp> getEmpListByDid(@Param("did") int did);
<!--List<Emp> getEmpListByDid(@Param("did") int did);-->
<select id="getEmpListByDid" resultType="Emp">
	select * from t_emp where did = #{did}
</select>

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

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

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

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

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

collection中的fetchType属性设置当前的分步查询是否使用延迟加载， fetchType="lazy(延迟加

载)|eager(立即加载)"```

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

9、动态SQL

Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了

解决 拼接SQL语句字符串时的痛点问题。

1.新建项目
2.配置文件
3.创建JavaBean
4.创建接口

9.1、if

if标签可通过test属性的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之

标签中的内容不会执行

9.2、where

where和if一般结合使用：

a>若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字

b>若where标签中的if条件满足，则where标签会自动添加where关键字，
c.where标签会字典将条件最前方多余的and去掉

也可以在where关键字后面加1=1
注意：where标签不能去掉条件最后多余的and

9.3、trim

trim用于去掉或添加标签中的内容

常用属性：

prefix：在trim标签中的内容的前面添加某些内容

prefixOverrides：在trim标签中的内容的前面去掉某些内容

suffix：在trim标签中的内容的后面添加某些内容

suffixOverrides：在trim标签中的内容的后面去掉某些内容

9.4、choose、when、otherwise

choose、when、 otherwise相当于if…else if…else
成立了就不会往下判断力

9.5、foreach

foreach中
collection:设置要循环的数组或集合
item：用一个字符串表示设置或集合中的每一个
separator：设置每次循环的数据之间的分隔符
open：循环的所有内容以什么开始
close：循环的所有内容以什么结束

批量添加
<!--void insertMoreEmp(@Param("emps") List<Emp> emps); 批量添加员工信息-->
    <select id="insertMoreEmp">
        insert into t_emp values 
        <foreach collection="emps" item="emp" separator=",">
            (null,#{emp.empName},#{emp.age},#{emp.gender},null,null)
        </foreach>
    </select>
批量删除
方式1
<!--int deleteMoreByArray(int[] eids);-->
<delete id="deleteMoreByArray">
	delete from t_emp where
	<foreach collection="eids" item="eid" separator="or">
		eid = #{eid}
	</foreach>
</delete>
方式2
<!--int deleteMoreByArray(int[] eids);-->
  <delete id="deleteMoreEmp">
        delete from t_emp where
        <foreach collection="empIds" item="empId" separator="or">
           emp_id =  #{empId}
        </foreach>
    </delete>

9.6、SQL片段

sql片段，可以记录一段公共sql片段，在使用的地方通过include标签进行引入

    <sql id="empColumns">
        emp_id,emp_name,age,gender,dept_id
    </sql>
<!--List<Emp> getEmpByCondition(Emp emp);-->
    <select id="getEmpByCondition" resultType="Emp">
        select <include refid="empColumns"></include> from t_emp
        <trim prefix="where" suffixOverrides="and">
        <if test="empName != null and empName != ''">
            emp_name= #{empName}
        </if>
        <if test="age != null and age != ''">
            and age=#{age}
        </if>
        <if test="gender!= null and gender != ''">
            and gender = #{gender}
        </if>
    </trim>

    </select>

keep going！