JAVAEE框架技术之8-myBatis ORM框架技术参数和动态SQL语句

淩亂°似流年 2023-09-29 17:20 9阅读 0赞

## parameterType ##

### 传入多个参数 ###

确切点是方法的输入参数，一般都是采用直接使用pojo类。此时在mapper.[xml][]文件中的SQL语句不用再写parameterType属性，而是用arg0,arg1,arg2,arg3…或者param1，param2，param3…代替。

#### 引出问题 ####

/**
         * 登录
         * @param name
         * @param passworld
         */
        public User login(String name ,String password);

<select id="login" resultType="User">
        select * from tb_user where user_name = #{username} and password = #{password}
    </select>

@Test
    public void testLogin(){
        
        User u = userMapper.login("jack","123");
        System.out.println(u);
    }

如果传入两个参数或者更多的参数，会发现，多个参数是找不到了，错误如下：

![在这里插入图片描述][af88a2a5b5ad45eea50f5f81e5435c90.png_pic_center]

### 解决方式1 ###

> 在mapper.xml中使用 0，1这样的序号去，0表示第一个参数，1表示第二个参数。（从0开始数）

<select id="login" resultType="User">
            select * from tb_user where user_name = #{arg0} and password = #{arg1}
        </select>

> 或者 用param1 param2 这个时就是从1开始

<select id="login" resultType="User">
            select * from tb_user where user_name = #{param1} and password = #{param2}
        </select>

### 解决方式2 ###

> 通过@Param来指定参数名,你写什么就接受什么

![在这里插入图片描述][fa8aa625e24f4f0c8584b1dcfbc0d3d5.png_pic_center]

## \#与$区别 ##

1、$字符串拼接，#参数站位相当于？
    2、$不能够防止sql注入，#可以防止sql注入的
    3、$要考虑参类型 ，#不用考虑参数类型  
    4、$可以替换sql语句任何一个内容，#只能替换参数

### \#的用法 ###

> \#\#\#\#\#\#不用考虑参数类型
> 
> \#\#\#\#\#\#可以防止sql注入

<select id="login" resultType="User">
        
        select * from tb_user where user_name = #{name} and passworld = #{password}
    </select>

/**
     * 登录
     */
    public User login(@Param("name") String name ,@Param("passworld") String passworld);

@Test
        public void testLogin(){
        
            User u = userMapper.login("jack", "123");//#不用考虑参数类型
            User u = userMapper.login("' or '1' = '1", "' or '1' = '1");//#防止sql注入
            System.out.println(u);
        }

*  **根据姓名进行模糊查询**

/**
         * 根据姓名进行模糊查询
         * @param name
         * @return
         */
        public List<User> queryByLikeName(String name);

<select id="queryByLikeName" resultType="User">
            select * from tb_user where user_name like concat('%',#{name},'%')
        </select>

@Test
        public void teseQueryByLikeName(){
        
            List<User> list = this.userMapper.queryByLikeName("ja");
            for(User user : list){
        
                System.out.println(user);
            }
        }

### $的用法 ###

> 用于字符串拼接

/**
         * 根据表名来查询
         * @param name
         */
        public List<User> queryByTableName(String name);

<select id="queryByTableName" resultType="User">
            select * from ${name}
        </select>

@Test
        public void testqueryByTableName(){
        
            List<User> list = this.userMapper.queryByTableName("tb_user");
            for(User user : list){
        
                System.out.println(user);
            }
        }

> $ 需要考虑参数类型
> 
> $不防止sql注入

<select id="login" resultType="User">
             
            select * from tb_user where user_name = '${name}' and passworld = '${passworld}'
        </select>

/**
     * 登录
     */
    public User login(@Param("name") String name ,@Param("passworld") String passworld);

@Test
        public void testLogin(){
        
            User u = userMapper.login("jack", "123");//$不用考虑参数类型
            User u = userMapper.login("' or '1' = '1", "' or '1' = '1");//$防止sql注入
            System.out.println(u);
        }

### \#和$的区别 ###

$可以代替所有#
    如果传入的数据，不是sql中的字段的时候，就不能够使用#. 
    
    通常使用#。
    选择获取参数的时候，首要选择的# 的方式
    （1、可以防止sql注入，2、可以不用考虑数据类型，简化书写，3、sql是参数的话的sql，预编译的sql，速度会块一些）
    当#用不了的时候，去选择$例如 ，sql需要改变是表名的情况，就可使用$的方式。
    
    总结：能用# 就不选择$

## ResultMap 用法 ##

ResultMap 是Mybatis中最为重要的元素，使用ResultMap 可以解决两大问题：

1、pojo属性名与数据库字段名不一致问题

2、完成高级查询，一对一，一对多， 多对多（后面讲）

### 代码实现 ###

<resultMap id="userResultMap" type="User" autoMapping="true">        
            
            <id column="id" property="id"/>        
            
            <result column="user_name" property="userName"/>        
            
            <result column="sex" property="sex"/>
        </resultMap>
        
        <select id="queryAllUser" resultMap="userResultMap">
            select * from tb_user
        </select>

## sql片段 ##

> 作用：把重复的sql语句抽出来来放到sql标签中，然后通来引入

### 用法1 ###

<sql id="userColumn">
            id ,user_name ,passworld , sex
        </sql>
    
        
        <select id="queryAllUser" resultMap="userResultMap">
            select <include refid="userColumn"/> from tb_user
        </select>

如出现以下问题，请参考解决即可：

![在这里插入图片描述][af8bf336b4614d17909d9c575e8d0dc4.png_pic_center]

![在这里插入图片描述][bd0a672fbe6544d9b835a2fbdec5a449.png_pic_center]

![在这里插入图片描述][e62b13f71b914559a1b31adf67ce6264.png_pic_center]

### 用法2 ###

> 以下用法1抽取的sql只能在本xml中使用，那如何这个抽取的sql其他xml也想使用怎么办呢？用法2就是可以将sql单独抽取到一个文件中，这样其他的xml就可以直接使用

<mapper namespace="abc">
        
        <sql id="userColumn">
            id ,user_name ,passworld , sex
        </sql>
    </mapper>

<select id="queryAllUser" resultMap="userResultMap">
            select <include refid="abc.userColumn"/> from tb_user
        </select>

<mapper resource="UserSQLMapper.xml"/>

## 动态sql ##

业务场景：在我们生活中很多业务常常遇到动态搜索的情况，比如搜索民宿，根据位置，价格，面积等等情况动态搜索，参数等信息可以根据我们需求改变，这里就涉及到了我们Mybatis常说的动态SQL。

Mybatis 动态SQL，通过 if, choose, when, otherwise, trim, where, set, foreach等标签，可组合成非常灵活的SQL语句，从而在提高 SQL 语句的准确性的同时，也大大提高了开发人员的效率。

Mybatis提供了动态SQL，也就是可以根据用户提供的参数，动态决定查询语句依赖的查询条件或SQL语句的内容。

<table> 
 <thead> 
  <tr> 
   <th>标签名</th> 
   <th>解释</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>if</td> 
   <td>单条件分支判断</td> 
  </tr> 
  <tr> 
   <td>choose, when, otherwise</td> 
   <td>多条件分支判断</td> 
  </tr> 
  <tr> 
   <td>where</td> 
   <td>处理sql条件接拼where</td> 
  </tr> 
  <tr> 
   <td>set</td> 
   <td>处理sql条件接拼set</td> 
  </tr> 
  <tr> 
   <td>foreach</td> 
   <td>循环操作</td> 
  </tr> 
  <tr> 
   <td>trim</td> 
   <td>处理sql条件拼接</td> 
  </tr> 
 </tbody> 
</table>

### 动态sql-if标签 ###

> 需求1：查询男性用户，如果输入了姓名，姓名进行模糊查找，如果不输入就按男性用户来查询

/**
            查询男性用户，如果输入了姓名，姓名进行模糊查找，如果不输入就按男性用户来查询
         */
        public List<User> queryLikeByName(String name);

<select id="queryLikeByName" resultType="User">
            select * from tb_user where sex = '男'
            <if test="name != null and name !=''">
                and user_name like concat('%',#{name},'%')
            </if>
        </select>

//查询男性用户，如果输入了姓名，姓名进行模糊查找，如果不输入就按男性用户来查询
        @Test
        public void queryLikeByName() {
        
    
            List<User> list = this.userMapper.queryLikeByName("ck");
            for(User user : list){
        
                System.out.println(user);
            }
        }

### 动态sql-choose, when, otherwise标签 ###

> choose,when,otherwise 相当于java中的 if, else if的逻辑
> 
> 如果其中的一个when 成立，则后的都不执行，如果所有when的都不成立，那么就执行otherwise
> 
> 也就是谁在前面谁优先
> 
> 需求2：查询男性用户，如果输入了姓名则按照姓名模糊查找，否则如果输入了年龄则按照年龄查找

/**
         * 查询男性用户，如果输入了姓名则按照姓名模糊查找，否则如果输入了年龄则按照年龄查找
         */
        public List<User> queryByLikeNameAndAge(@Param("name") String name , @Param("age") Integer age);

<select id="queryByLikeNameAndAge" resultType="User">
            select * from tb_user where sex = '男'
            <choose>
                <when test="name != null and name !=''">
                    and user_name like concat('%',#{name},'%')
                </when>
                <when test="age != null and age !=''">
                    and age like concat('%',#{age},'%')
                </when>
                <otherwise>
                    and id = 12
                </otherwise>
            </choose>
        </select>

//查询男性用户，如果输入了姓名则按照姓名模糊查找，否则如果输入了年龄则按照年龄查找
    	@Test
        public void queryByLikeNameAndAge(){
        
            List<User> list = this.userMapper.queryByLikeNameAndAge("jack", null);
            for(User user : list){
        
                System.out.println(user);
            }
        }

### 动态sql-where标签 ###

> where标签代替 sql中的where关键字
> 
> 需求3：查询所有用户，如果输入了姓名按照姓名进行模糊查询，如果输入年龄，按照年龄进行查询

/**
    * 查询所有用户，如果输入了姓名按照姓名进行模糊查询，如果输入年龄，按照年龄进行查询
    */
    public List<User> queryByAllUserLikeNameAndAge(@Param("name") String name , @Param("age") Integer age);

<select id="queryByAllUserLikeNameAndAge" resultType="User">
            select * from tb_user
            <where>
                <if test="name != null and name!=''">
                    user_name like concat('%',#{name},'%')
                </if>
                <if test="age != null and age!=''">
                    and age like concat('%',#{age},'%')
                </if>
            </where>
        </select>

//查询所有用户，如果输入了姓名按照姓名进行模糊查询，如果输入年龄，按照年龄进行查询
        @Test
        public void queryByAllUserLikeNameAndAge(){
        
            List<User> list = this.userMapper.queryByAllUserLikeNameAndAge("c", 2);
            for(User user : list){
        
                System.out.println(user);
            }
        }

### 动态sql-set标签 ###

> set标签代替 sql中set关键字
> 
> 需求4：如果名字信息不是null，则修改名字， 如果age信息不是null,同时也修改age

/**
    * 如果名字信息不是null，则修改名字， 如果age信息不是null,同时也修改age
    */
    public Integer updateByNameOrAge(@Param("name") String name , @Param("age") Integer age , @Param("id") Integer id);

<update id="updateByNameOrAge">
            update tb_user
            <set>
                <if test="name != null and name!=''">
                    user_name =  #{name},
                </if>
                <if test="age != null and age!=''">
                    age = #{age}
                </if>
            </set>
            where id = #{id}
        </update>

//如果名字信息不是null，则修改名字， 如果age信息不是null,同时也修改age
        @Test
        public void updateByNameOrAge(){
        
            Integer integer = this.userMapper.updateByNameOrAge("一燕", 26, 2);
            sqlSession.commit();
            System.out.println(integer);
        }

### 动态sql-foreach标签 ###

> 需求5：按照多个id查询用户信息 Select \* from t\_user where id in(1,2,3)

/**
         * 按照多个id查询用户信息
         * @param ids
         * @return
         */
        public List<User> queryIds(@Param("ids") int[] ids);

<select id="queryIds" resultType="User">        
            select * from tb_user where id in
            <foreach collection="ids" item="id" open="(" close=")" separator=",">
                #{id}
            </foreach>
        </select>

// 按照多个id查询用户信息
        @Test
        public void queryIds(){
        
            int[] arr ={
        1,2};
            List<User> list = this.userMapper.queryIds(arr);
            for(User user : list){
        
                System.out.println(user);
            }
        }

### 动态sql-trim标签 ###

trim元素的主要功能是可以在自己包含的内容前加上某些前缀，也可以在其后加上某写后缀，与之对应的属性是prefix和suffix；

可以把包含内容的首部某些内容覆盖，即忽略，也可以把尾部的某些内容覆盖，对应的属性是prefixOverrides和suffixOver

![在这里插入图片描述][9031d9b9ae2044079b5622455d90d111.png_pic_center]

*  **案例一** prefix用法

/**
     * 查询所有，如果输入姓名，按姓名查询，如果输入性别，就按性别来查询
     */
    public List<User> queryNameAndSexTrim(@Param("name") String name , @Param("sex") String sex);

<select id="queryNameAndSexTrim" resultType="User">
            select * from tb_user
            /*加前缀，去掉第一个前缀*/
            <trim prefix="where" prefixOverrides="and">
                <if test="name != null and name !=''">
                    and user_name = #{name}
                </if>
                <if test="sex != null and sex !=''">
                    and sex = #{sex}
                </if>
            </trim>
        </select>

//查询所有，如果输入姓名，按姓名查询，如果输入性别，就按性别来查询
        @Test
        public void queryNameAndSexTrim(){
        
            List<User> list = this.userMapper.queryNameAndSexTrim("jack", "男");
            for(User user : list){
        
                System.out.println(user);
            }
        }

*  \*\*案例二 \*\* suffix用法

/**
    * 如果名字信息不是null，则修改名字， 如果sex不为null,同时也修改null
    */
    public Integer updateByNameOrAgeTrim(@Param("name") String name , @Param("sex") String sex , @Param("id") Integer id);

<update id="updateByNameOrAgeTrim">
            update tb_user
            <trim prefix="set" suffixOverrides="," suffix="where id = #{id}">
                <if test="name != null and name !=''">
                    user_name = #{name},
                </if>
                <if test="sex != null and sex !=''">
                    sex = #{sex},
                </if>
            </trim>
        </update>

//如果名字信息不是null，则修改名字， 如果sex不为null,同时也修改null
    @Test
    public void updateByNameOrAgeTrim(){
        
        Integer integer = this.userMapper.updateByNameOrAgeTrim("小江", "女", 2);
        sqlSession.commit();
        System.out.println(integer);
    
    }

## 缓存 ##

### 一级缓存 ###

> Mybatis的一级缓存的作用域session,当openSession()后，如果执行相同的sql和参数，Mybatis不再执行SQL,而是从缓存中命中并返回；
> 
> 原理：mybatis执行查询时首先去缓存中命中，如果命中就直接返回，没有命中则执行SQL，从数据库中查
> 
> 在mybatis中，一级缓存默认是开启的，并且一直无法关闭（我们没法去管理一级缓存

#### 测试一级缓存 ####

@Test
        public void queryById(){
        
            User user = this.userMapper.queryById(2);//发送sql
            System.out.println(user);
    
            User user2 = this.userMapper.queryById(2);//不发送sql
            System.out.println(user2);
        }

#### 清空缓存 ####

> 使用sqlsession.clearCache()清除缓存

@Test
        public void queryById(){
        
    
            User user = this.userMapper.queryById(2);//发送sql
            System.out.println(user);
    
            sqlSession.clearCache();//清空缓存
    
            User user2 = this.userMapper.queryById(2);//重新发送sql
            System.out.println(user2);
        }

> 执行update,delete,insert 语句的时候，清空缓存 刷新缓存

@Test
        public void queryById(){
        
    
            User user = this.userMapper.queryById(2);//发送sql
            System.out.println(user);
    
            Integer i = this.userMapper.deleteById(1);//执行删除操作
            sqlSession.commit();
            System.out.println(i);
    	//只要执行任意的增删改，则会清空缓存;
            User user2 = this.userMapper.queryById(2);//发送sql
            System.out.println(user2);
        }

### 二级缓存 ###

> mybatis 的二级缓存的作用域是一个mapper的namespace ，同一个namespace中查询sql可以从缓存中命中。
> 
> 二级缓存是跨session

#### 开启二级缓存 ####

需要在当前sql映射文件中开启二缓缓存

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper
            PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="cn.yanqi.mapper.UserMapper">    
        
        <cache/>

#### 测试二级缓存 ####

@Test
    public void queryById(){
        
        User user = this.userMapper.queryById(2);//发送sql
        System.out.println(user);
        //关闭sqlSession
        sqlSession.close();	
        SqlSession sqlSession = sqlSessionFactory.openSession();
        userMapper = sqlSession.getMapper(UserMapper.class);
    
        User user2 = this.userMapper.queryById(2);//不发送sql，表明二级缓存存在
        System.out.println(user2);
    }

查看日志输出

![在这里插入图片描述][d8bd9c5c3db54c0198f045357b84378a.png_pic_center]

#### 关闭二级缓存 ####

![在这里插入图片描述][3d512124ebcd4eedb6555304922ca2a5.png_pic_center]

![在这里插入图片描述][276aa0e038ef442eb6f1e38d8262f497.png_pic_center]

![在这里插入图片描述][4fdb7d8c6bad4e0da1e2e2428f7dac35.png_pic_center]

Mybatis一级缓存  
1.为什么需要Mybatis一级缓存  
当我们使用Mybatis进行数据库的操作时候，会创建一个SqlSession来进行一次数据库的会话，会话结束则关闭SqlSession对象。

如果我们很有可能多次查询完全相同的sql语句，每一次查询都查询一次数据库，那查询数据库代价是比较大的，这会导致系统的资源浪费。

为了解决这个问题，Mybatis对每一次会话都添加了缓存操作，不用相同的SQL每次都需要查询数据库，这就是Mybatis一级缓存的作用。

2.Mybatis一级缓存的实现  
我们知道对SqlSession的操作，mybatis内部都是通过Executor来执行的，Executor的生命周期和SqlSession是一致的。

Mybatis在Executor中创建了本地缓存(一级缓存)，如下图所示：

![在这里插入图片描述][c4c50abd802b472da35e95cbf7448048.png_pic_center]

大致的流程如下：

第一次查询用户id信息，先去缓存中查询是否有，如果没有，从数据库中查询用户信息，得到用户信息后在将用户信息储存到一级缓存中。

如果sqlSession去执行commit操作（插入、更新、删除），清空sqlSession中的一级缓存，保证缓存中始终保存的是最新的信息，避免脏读。

第二次查询用户id信息，先去缓存中查询，如缓存中有，直接从缓存中获取。

注意：两次查询须在同一个sqlsession中完成，否则将不会走mybatis的一级缓存。

在mybatis与spring进行整合开发时，事务控制在service中进行，重复调用两次servcie将不会走一级缓存，因为在第二次调用时session方法结束，SqlSession就关闭了。

3.Mybatis一级缓存配置  
mybatis一级缓存的范围有SESSION和STATEMENT两种，默认是SESSION。

如果不想使用一级缓存，可以把一级缓存的范围指定为STATEMENT，这样每次执行完一个Mapper中的语句后都会将一级缓存清除。

如果需要更改一级缓存的范围，可以在Mybatis的配置文件中，在下通过localCacheScope指定。

Mybatis二级缓存 1.为什么需要Mybatis二级缓存？ MyBatis 一级缓存最大的共享范围就是一个SqlSession内部，那么如果多个 SqlSession 需要共享缓存，则需要开启二级缓存。

2.Mybatis二级缓存的实现  
开启二级缓存后，会使用 CachingExecutor 装饰 Executor，进入一级缓存的查询流程前，先在 CachingExecutor 进行二级缓存的查询，具体的工作流程如下所示。

![在这里插入图片描述][21b1736f505a480b9828809004079411.png_pic_center]

二级缓存开启后，同一个 namespace 下的所有操作语句，都影响着同一个 Cache，即二级缓存被多个 SqlSession 共享，是一个全局的变量。

当开启缓存后，数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。

MyBatis 是默认关闭二级缓存的，因为对于增删改操作频繁的话，那么二级缓存形同虚设，每次都会被清空缓存。

Mybatis一级缓存与二级缓存的区别  
1）一级缓存 Mybatis的一级缓存是指SQLSession，一级缓存的作用域是SQlSession, Myabits默认开启一级缓存。

在同一个SqlSession中，执行相同的SQL查询时；第一次会去查询数据库，并写在缓存中，第二次会直接从缓存中取。 当执行SQL时候两次查询中间发生了增删改的操作，则SQLSession的缓存会被清空。

每次查询会先去缓存中找，如果找不到，再去数据库查询，然后把结果写到缓存中。 Mybatis的内部缓存使用一个HashMap，key为hashcode+statementId+sql语句。Value为查询出来的结果集映射成的java对象。 SqlSession执行insert、update、delete等操作commit后会清空该SQLSession缓存。

2） Mybatis二级缓存是默认不开启的，作用于一个Application，是Mapper级别的，多个SqlSession使用同一个Mapper的sql能够使用二级缓存。  
xecutor 装饰 Executor，进入一级缓存的查询流程前，先在 CachingExecutor 进行二级缓存的查询，具体的工作流程如下所示。

\[外链图片转存中…(img-TITjBxut-1665230984236)\]

二级缓存开启后，同一个 namespace 下的所有操作语句，都影响着同一个 Cache，即二级缓存被多个 SqlSession 共享，是一个全局的变量。

当开启缓存后，数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。

MyBatis 是默认关闭二级缓存的，因为对于增删改操作频繁的话，那么二级缓存形同虚设，每次都会被清空缓存。

Mybatis一级缓存与二级缓存的区别  
1）一级缓存 Mybatis的一级缓存是指SQLSession，一级缓存的作用域是SQlSession, Myabits默认开启一级缓存。

2） Mybatis二级缓存是默认不开启的，作用于一个Application，是Mapper级别的，多个SqlSession使用同一个Mapper的sql能够使用二级缓存。

[xml]: https://so.csdn.net/so/search?q=xml&spm=1001.2101.3001.7020
[af88a2a5b5ad45eea50f5f81e5435c90.png_pic_center]: https://img-blog.csdnimg.cn/af88a2a5b5ad45eea50f5f81e5435c90.png#pic_center
[fa8aa625e24f4f0c8584b1dcfbc0d3d5.png_pic_center]: https://img-blog.csdnimg.cn/fa8aa625e24f4f0c8584b1dcfbc0d3d5.png#pic_center
[af8bf336b4614d17909d9c575e8d0dc4.png_pic_center]: https://img-blog.csdnimg.cn/af8bf336b4614d17909d9c575e8d0dc4.png#pic_center
[bd0a672fbe6544d9b835a2fbdec5a449.png_pic_center]: https://img-blog.csdnimg.cn/bd0a672fbe6544d9b835a2fbdec5a449.png#pic_center
[e62b13f71b914559a1b31adf67ce6264.png_pic_center]: https://img-blog.csdnimg.cn/e62b13f71b914559a1b31adf67ce6264.png#pic_center
[9031d9b9ae2044079b5622455d90d111.png_pic_center]: https://img-blog.csdnimg.cn/9031d9b9ae2044079b5622455d90d111.png#pic_center
[d8bd9c5c3db54c0198f045357b84378a.png_pic_center]: https://img-blog.csdnimg.cn/d8bd9c5c3db54c0198f045357b84378a.png#pic_center
[3d512124ebcd4eedb6555304922ca2a5.png_pic_center]: https://img-blog.csdnimg.cn/3d512124ebcd4eedb6555304922ca2a5.png#pic_center
[276aa0e038ef442eb6f1e38d8262f497.png_pic_center]: https://img-blog.csdnimg.cn/276aa0e038ef442eb6f1e38d8262f497.png#pic_center
[4fdb7d8c6bad4e0da1e2e2428f7dac35.png_pic_center]: https://img-blog.csdnimg.cn/4fdb7d8c6bad4e0da1e2e2428f7dac35.png#pic_center
[c4c50abd802b472da35e95cbf7448048.png_pic_center]: https://img-blog.csdnimg.cn/c4c50abd802b472da35e95cbf7448048.png#pic_center
[21b1736f505a480b9828809004079411.png_pic_center]: https://img-blog.csdnimg.cn/21b1736f505a480b9828809004079411.png#pic_center