MyBatis常用标签以及使用技巧总结

2024-10-05 12:11:34

前言

MyBatis常用标签及标签使用技巧

MyBatis的常用标签有很多，比如

<sql id="">：预定义可以复用的sql语句

<include refid="">：根据id引用定义的sql语句

<trim>：空白补全，配合<if>标签使用

<if test="">：条件判断，该语句返回的true，则该标签内的语句就生效

<bind name="" value="">：创建一个变量，并且可以绑定到上下文

1、统一的增删改

通过我暂时的开发经验来说，我认为对一张表增删改操作，起码包括：增加一条记录、删除一条记录、修改一条记录。所以一张表的操作起码包括：增删改。

增加一条是主键id自增，删除一条记录是根据主键id删除，修改一条记录是根据主键id修改，返回值都是Integer类型的成功增删改的记录条数。以User对象为例：

UserMapper.java：

@Mapper
@Repository
public interface UserMapper {

    /**
     * 增加一条记录
     * @param user 用户对象
     * @return 增加成功的记录数
     */
    Integer insertOne(User user);

    /**
     * 删除一条记录
     * @param user 用户对象
     * @return 删除成功的记录数
     */
    Integer deleteOne(User user);

    /**
     * 修改用户
     * @param user 用户对象
     * @return 修改成功的记录数
     */
    Integer updateOne(User user);
}

则对应的UserMapper.xml：

<mapper namespace="UserMapper">
    <!--update的条件sql（除了自增主键id）-->
    <sql id="updateCondition">
        <if test=" uuid!=null and uuid!='' ">
            uuid = #{uuid},
        </if>
        <if test=" username!=null and username!='' ">
            username = #{username},
        </if>
        <if test=" password!=null and password!='' ">
            password = #{password},
        </if>
    </sql>
    <!--新增一条-->
    <insert id="insertOne"
            keyProperty="id"
            useGeneratedKeys="true"
            parameterType="User">
        INSERT INTO
            user
            (uuid,username,password)
        VALUES
            (#{uuid},#{username},#{password})
    </insert>
    <!--删除一条-->
    <delete id="deleteOne"
            parameterType="User">
        DELETE FROM user WHERE id = #{id}
    </delete>
    <!--修改一条（根据id主键）-->
    <update id="updateOne"
            parameterType="User">
        UPDATE
            user
        <trim prefix="SET" suffixOverrides=",">
            <include refid="updateCondition"></include>
        </trim>
        WHERE
            id = #{id}
    </update>
</mapper>

由于一般修改语句是根据id，所以在<update>标签中，WHERE id = #{id}是写死了的。一般修改的话，是除了id可以修改其余都是可以修改的，所以一般字段会比较多，利用<sql>标签预定义好除了id的字段，并且利用<if>标签包裹起来，同时特别注意：最后要加上逗号。然后在<trim>标签中利用<include>标签引用预定义的修改语句的条件。<include>标签就相当于直接把该id的sql语句直接粘贴到这里，这里是为了看起整体排版比较舒服所以才这么做的。

2、统一的查询

通过我暂时的开发经验来说，我认为对一张表查询操作，起码包括：查询多条记录（可分页可条件）、查询一条记录（可条件），查询该表的总记录数。所以一张表的操作起码包括：三个查询。

查询列表、单个查询、查询该表的总记录数，同样是以User对象为例：

UserMapper.java：

@Mapper
@Repository
public interface UserMapper {

    /**
     * 查询所有user集合（可分页，可多条件，可单条件）
     * @param user 用户对象
     * @return user集合
     */
    List<User> selectList(User user);

    /**
     * 查询一条user记录（可多条件，可单条件）
     * @param user
     * @return  一条用户对象
     */
    User selectOne(User user);

    /**
     * 查询记录数（可条件查询）
     * @param user  用户对象
     * @return  记录数
     */
    Long count(User user);

}

分别返回User集合、单个User对象以及记录数。

对应的UserMapper.xml：

<mapper namespace="UserMapper">
    <!--select的条件sql（全有）-->
    <sql id="selectCondition">
        <if test=" id!=null and id!='' ">
            AND u.id = #{id}
        </if>
        <if test=" uuid!=null and uuid!='' ">
            AND u.uuid = #{uuid}
        </if>
        <if test=" username!=null and username!='' ">
            AND u.username = #{username}
        </if>
        <if test=" password!=null and password!='' ">
            AND u.password = #{password}
        </if>
    </sql>
    <!--分页的条件sql（当前页，每页记录数）-->
    <sql id="limitCondition">
        <if test=" currentPage!=null and currentPage!='' and pageSize!=null and pageSize!='' ">
            <bind name="offset" value="pageSize*(currentPage-1)"/>
            <bind name="rows" value="pageSize"/>
            #{offset},#{rows}
        </if>
    </sql>
    <!--user表的别名-->
    <sql id="userAs">
        u.id                AS uId,
        u.uuid              AS uUuid,
        u.username          AS uUsername,
        u.password          AS uPassword
    </sql>
    <!--返回的结果集-->
    <resultMap id="userMap" type="User">
        <id column="uId" property="id"/>
        <result column="uUuid" property="uuid"/>
        <result column="uUsername" property="username"/>
        <result column="uPassword" property="password"/>
    </resultMap>
    <!--查询所有（可分页，可单条件，可多条件）-->
    <select id="selectList"
            parameterType="User"
            resultMap="userMap">
        SELECT
            <include refid="userAs"></include>
        FROM
            user u
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
        ORDER BY
            u.id
        <trim prefix="LIMIT">
            <include refid="limitCondition"></include>
        </trim>
    </select>
    <!--查询一条（可单条件，可多条件）-->
    <select id="selectOne"
            parameterType="User"
            resultMap="userMap">
        SELECT
            <include refid="userAs"></include>
        FROM
            user u
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
    </select>
    <!--查询记录数（可单条件，可多条件）-->
    <select id="count"
            parameterType="User"
            resultType="long">
        SELECT
            count(u.id)
        FROM
            user u
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
    </select>
</mapper>

根据三个需求：查询全表、查询单个两个都可以用到条件查询，所以都可以用到同样的sql，所以就可以使用同样的<sql>标签来预定义然后复用。小结一下就是：

查询全表：查询字段、可全条件、可分页
查询单个：查询字段、可全条件
查询记录数：可全条件

得益于<trim>标签和<if>标签的配合（if标签判断条件是否成立，如果成立则if标签内部语句生效，trim判断内部是否有语句，如果有则trim生效），没有条件传入就查询全表，没有分页传入的时候就不分页，做到了有条件则查条件，无条件则全查，有分页则查分页，无分页则全查。同时定义好结果集映射（column是查出来的列，property是Pojo对象的属性，需要对应好）以及配置好查询字段的别名（AS）。定义结果集和配置查询字段的别名是方便以后扩展。

条件查询的<sql>需要注意的是利用AND连接。

分页的<sql>需要注意的是利用<bind>标签来定义变量，注意变量的换算，一般采用的是传入当前页（currentPage）和每页记录数（pageSize），而数据库中limit语句的参数是limit offset,rows，offset（偏移量，也就是从表中的第几个元素开始，0是首位），rows（记录数，也就是返回多少个），总的来说就是从第几个开始，返回第条记录。然后利用简单的数学换算，将currentPage和pageSize转换为offset和rows。

<trim>标签的使用，利用<include>标签引入相应的sql语句后，再用<trim>标签包围，注意好prefix、suffix、prefixOverrides和suffixOverrides。

注意

SQL语句中各关键字的顺序

3、统一的增删改查

最后将增删改和查询总结合并起来就是：

UserMapper.java：

@Mapper
@Repository
public interface UserMapper {

    /**
     * 增加一条记录
     * @param user 用户对象
     * @return 增加成功的记录数
     */
    Integer insertOne(User user);

    /**
     * 删除一条记录
     * @param user 用户对象
     * @return 删除成功的记录数
     */
    Integer deleteOne(User user);

    /**
     * 修改用户
     * @param user 用户对象
     * @return 修改成功的记录数
     */
    Integer updateOne(User user);

    /**
     * 查询所有user集合（可分页，可多条件，可单条件）
     * @param user 用户对象
     * @return user集合
     */
    List<User> selectList(User user);

    /**
     * 查询一条user记录（可多条件，可单条件）
     * @param user
     * @return  一条用户对象
     */
    User selectOne(User user);

    /**
     * 查询记录数（可条件查询）
     * @param user  用户对象
     * @return  记录数
     */
    Long count(User user);

}

UserMapper.xml：

<mapper namespace="UserMapper">
    <!--select的条件sql（全有）-->
    <sql id="selectCondition">
        <if test=" id!=null and id!='' ">
            AND u.id = #{id}
        </if>
        <if test=" uuid!=null and uuid!='' ">
            AND u.uuid = #{uuid}
        </if>
        <if test=" username!=null and username!='' ">
            AND u.username = #{username}
        </if>
        <if test=" password!=null and password!='' ">
            AND u.password = #{password}
        </if>
    </sql>
    <!--update的条件sql（除了自增主键id）-->
    <sql id="updateCondition">
        <if test=" uuid!=null and uuid!='' ">
            uuid = #{uuid},
        </if>
        <if test=" username!=null and username!='' ">
            username = #{username},
        </if>
        <if test=" password!=null and password!='' ">
            password = #{password},
        </if>
    </sql>
    <!--分页的条件sql（当前页，每页记录数）-->
    <sql id="limitCondition">
        <if test=" currentPage!=null and currentPage!='' and pageSize!=null and pageSize!='' ">
            <bind name="offset" value="pageSize*(currentPage-1)"/>
            <bind name="rows" value="pageSize"/>
            #{offset},#{rows}
        </if>
    </sql>
    <!--user表的别名-->
    <sql id="userAs">
        u.id                AS uId,
        u.uuid              AS uUuid,
        u.username          AS uUsername,
        u.password          AS uPassword
    </sql>
    <!--返回的结果集-->
    <resultMap id="userMap" type="User">
        <id column="uId" property="id"/>
        <result column="uUuid" property="uuid"/>
        <result column="uUsername" property="username"/>
        <result column="uPassword" property="password"/>
    </resultMap>
    <!--新增一条-->
    <insert id="insertOne"
            keyProperty="id"
            useGeneratedKeys="true"
            parameterType="User">
        INSERT INTO
            user
            (uuid,username,password)
        VALUES
            (#{uuid},#{username},#{password})
    </insert>
    <!--删除一条-->
    <delete id="deleteOne"
            parameterType="User">
        DELETE FROM user WHERE id = #{id}
    </delete>
    <!--修改一条（根据id主键）-->
    <update id="updateOne"
            parameterType="User">
        UPDATE
            user
        <trim prefix="SET" suffixOverrides=",">
            <include refid="updateCondition"></include>
        </trim>
        WHERE
            id = #{id}
    </update>
    <!--查询所有（可分页，可单条件，可多条件）-->
    <select id="selectList"
            parameterType="User"
            resultMap="userMap">
        SELECT
            <include refid="userAs"></include>
            user u
            JOIN role r on u.roleId = r.id
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
        ORDER BY
            u.id
        <trim prefix="LIMIT">
            <include refid="limitCondition"></include>
        </trim>
    </select>
    <!--查询一条（可单条件，可多条件）-->
    <select id="selectOne"
            parameterType="User"
            resultMap="userMap">
        SELECT
            <include refid="userAs"></include>
        FROM
            user u
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
    </select>
    <!--查询记录数（可单条件，可多条件）-->
    <select id="count"
            parameterType="User"
            resultType="long">
        SELECT
            count(u.id)
        FROM
            user u
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
    </select>
</mapper>

对一张表的操作最起码就应该包括以上：增加一条记录、删除一条记录、修改一条记录、查询列表（可条件、可分页）、查询一条（可条件）、查询记录数（可条件）。

4、利用IDEA的Code Templates自动生成

总结后观察到，每张表都有这6个操作，并且代码基本上都大致相同，差别只是对象的名字和表中字段不一样，那我每次创建Mapper文件都需要手敲吗？NoNoNo，可以利用IDEA的Code Templates功能，预先定义好Mapper Java和Mapper Xml的大致结构，然后利用传参传入对象名就可以了，这样每次就能自动生成大量代码，然后只需要修改极少部分代码就可以了。

Code Templates文件的创建：

打开IDEA，左上角依次点击：File->搜索template->找到File and Code Templates，在右侧创建新文件，输入文件名，扩展名Java：

#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "") package ${PACKAGE_NAME};#end

import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;
#parse("File Header.java")

@Mapper
@Repository
public interface ${NAME} {

    /**
     * 增加一条记录
     * @param ${pojo} ${name}对象
     * @return 增加成功的记录数
     */
    Integer insertOne(${Pojo} ${pojo});

    /**
     * 删除一条记录
     * @param ${pojo} ${name}对象
     * @return 删除成功的记录数
     */
    Integer deleteOne(${Pojo} ${pojo});

    /**
     * 修改一条记录
     * @param ${pojo} ${name}对象
     * @return 修改成功的记录数
     */
    Integer updateOne(${Pojo} ${pojo});

    /**
     * 查询所有集合（可分页，可多条件，可单条件）
     * @param ${pojo} ${name}对象
     * @return ${pojo}集合
     */
    List<${Pojo}> selectList(${Pojo} ${pojo});

    /**
     * 查询一条${pojo}记录（可多条件，可单条件）
     * @param ${pojo} ${name}对象
     * @return  一条${name}对象
     */
    ${Pojo} selectOne(${Pojo} ${pojo});

    /**
     * 查询记录数（可条件查询）
     * @param ${pojo}  ${name}对象
     * @return  记录数
     */
    Long count(${Pojo} ${pojo});

}

${Pojo}：Pojo对象的类名

${pojo}：Pojo对象的变量名

这样下次在新建Mapper.java文件的时候直接利用该template创建就可以了。

同样的，Mapper.xml：

<?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="${PRE}.mapper.${NAME}">
    <!--select的条件sql（全有）-->
    <sql id="selectCondition">
        <if test=" arg!=null and arg!='' ">
            AND arg = #{arg}
        </if>
    </sql>
    <!--update的条件sql（除了自增主键id）-->
    <sql id="updateCondition">
        <if test=" arg!=null and arg!='' ">
            arg = #{arg},
        </if>
    </sql>
    <!--分页的条件sql（当前页，每页记录数）-->
    <sql id="limitCondition">
        <if test=" currentPage!=null and currentPage!='' and pageSize!=null and pageSize!='' ">
            <bind name="offset" value="pageSize*(currentPage-1)"/>
            <bind name="rows" value="pageSize"/>
            #{offset},#{rows}
        </if>
    </sql>
    <!--返回的结果集-->
    <resultMap id="${Pojo}Map" type="${PRE}.pojo.${Pojo}">
        <id column="id" property="id"/>
        <result column="" property=""/>
    </resultMap>
    <!--新增一条记录-->
    <insert id="insertOne"
            keyProperty="id"
            useGeneratedKeys="true"
            parameterType="${PRE}.pojo.${Pojo}">
        INSERT INTO
            ${TABLE_NAME}
            ()
        VALUES
            ()
    </insert>
    <!--删除一条记录-->
    <delete id="deleteOne"
            parameterType="${PRE}.pojo.${Pojo}">
        DELETE FROM
            ${TABLE_NAME}
        WHERE
            id = #{id}
    </delete>
    <!--修改一条记录（根据id主键）-->
    <update id="updateOne"
            parameterType="${PRE}.pojo.${Pojo}">
        UPDATE
            ${TABLE_NAME}
        <trim prefix="SET" suffixOverrides=",">
            <include refid="updateCondition"></include>
        </trim>
        WHERE
            id = #{id}
    </update>
    <!--查询所有（可分页，可单条件，可多条件）-->
    <select id="selectList"
            parameterType="${PRE}.pojo.${Pojo}"
            resultMap="${Pojo}Map">
        SELECT
            *
        FROM
            ${TABLE_NAME}
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
        ORDER BY
            id
        <trim prefix="LIMIT">
            <include refid="limitCondition"></include>
        </trim>
    </select>
    <!--查询一条（可单条件，可多条件）-->
    <select id="selectOne"
            parameterType="${PRE}.pojo.${Pojo}"
            resultMap="${Pojo}Map">
        SELECT
            *
        FROM
            ${TABLE_NAME}
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
    </select>
    <!--根据主键id（效率高）查询记录数（可单条件，可多条件）-->
    <select id="count"
            parameterType="${PRE}.pojo.${Pojo}"
            resultType="long">
        SELECT
            count(id)
        FROM
            ${TABLE_NAME}
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
    </select>
</mapper>

${PRE}：包的前缀

${Pojo}：对象的类名

${TABLE_NAME}：表名

即可以非常快速地生成Mapper.java和Mapper.xml了

5、连接关系表

因为Mybatis的特性，它可以连表查询。同样的，我们利用上述的方法创建好RoleMapper，如果想要在UserMapper中使用RoleMapper中定义好的sql，那么直接使用<include refid="包名+id">，下面是在UserMapper.xml中使用user表和role表连表查询列表举例：

	<!--查询所有（可分页，可单条件，可多条件）-->
    <select id="selectList"
            parameterType="com.fangaoxs.userserver.pojo.User"
            resultMap="userMap">
        SELECT
            <include refid="userAs"></include>,
            <include refid="com.xxx.userserver.mapper.RoleMapper.roleAs"></include>
        FROM
            user u
            JOIN role r on u.roleId = r.id
        <trim prefix="WHERE" prefixOverrides="AND">
            <include refid="selectCondition"></include>
        </trim>
        ORDER BY
            u.id
        <trim prefix="LIMIT">
            <include refid="limitCondition"></include>
        </trim>
    </select>

那么，这样就实现了user表和role的联合查询，并且roleMapper.xml中的<sql>也在userMapper.xml中得到了复用。

总结

到此这篇关于MyBatis常用标签以及使用技巧总结的文章就介绍到这了,更多相关MyBatis常用标签使用技巧内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

Mybatis传单个参数和<if>标签同时使用的问题及解决方法

// Mapper.java EmerEvent selectByAlarmId(Integer alarmId); // Mapper.xml <select id="selectByAlarmId" resultMap="BaseResultMap" parameterType="java.lang.Integer"> select <include refid="Base_Column_List" /&
MyBatis动态SQL标签用法实例详解

1.动态SQL片段通过SQL片段达到代码复用  <sql id="sql_count"> select count(*) </sql> <sql id="sql_select"> select * </sql> <sql id="sql_where"> from icp <dynamic prepend="where&quo
MyBatis常用标签大全

_parameter _parameter 表示当前传入的参数,如果查询的时候传入的参数只有一个,则使用 _parameter E getById(Integer id); <select id="getById" parameterType="int" resultMap="BaseResultMap"> SELECT * FROM 库名.表名 WHERE id = #{_parameter} </select> if判
MyBatis动态Sql之if标签的用法详解

最近在读刘增辉老师所著的<MyBatis从入门到精通>一书,很有收获,于是将自己学习的过程以博客形式输出,如有错误,欢迎指正,如帮助到你,不胜荣幸! 本篇博客主要讲解如何使用if标签生成动态的Sql,主要包含以下3个场景: 1.根据查询条件实现动态查询 2.根据参数值实现动态更新某些列 3.根据参数值实现动态插入某些列 1. 使用if标签实现动态查询假设有这样1个需求:根据用户的输入条件来查询用户列表,如果输入了用户名,就根据用户名模糊查询,如果输入了邮箱,就根据邮箱精确查询,如果同时输入了
Mybatis中Collection集合标签的使用详解

mybatis简单的CURD就不用多说了,网上相关博客文档一大堆.分析一下Mybatis里面的collection聚集查询. 假设一个班级有多名学生为例,通过班级号查询出该班级的信息,和班级里面的所有学生的信息,一般的做法就是通过班级号把班级的信息查询出来,再通过班级ID号把该班级里面的所有学生查询出来,我们不用这种通用的方法 1.班级实体类可以定义为这样: import java.util.List; public class ClazzEntity { private int clazzID
MyBatis动态SQL中的trim标签的使用方法

trim标记是一个格式化的标记,可以完成set或者是where标记的功能,如下代码: 1. select * from user <trim prefix="WHERE" prefixoverride="AND |OR"> <if test="name != null and name.length()>0"> AND name=#{name}</if> <if test="gender
Mybatis foreach标签使用不当导致异常的原因浅析

异常产生场景及异常信息上周,由于在Mybatis的Mapper接口方法中使用实现了Map.Entry接口的泛型类,同时此方法对应的sql语句也使用了foreach标签,导致出现了异常.如下为异常信息: org.apache.ibatis.exceptions.PersistenceException: ### Error updating database. Cause: org.apache.ibatis.reflection.ReflectionException: There is no
mybatis if标签使用总结

在项目开发中,mybatis <if> 标签使用广泛,本文讲解if标签的两种使用方式其一.使用 <if> 标签判断某一字段是否为空其二.使用 <if> 标签判断传入参数是否相等具体代码如下数据库表结构和数据实体类 package com.demo.bean; public class Commodity { private String name; private String date; public String getName() { return na
MyBatis常用标签以及使用技巧总结

前言 MyBatis常用标签及标签使用技巧 MyBatis的常用标签有很多,比如 <sql id="">:预定义可以复用的sql语句 <include refid="">:根据id引用定义的sql语句 <trim>:空白补全,配合<if>标签使用 <if test="">:条件判断,该语句返回的true,则该标签内的语句就生效 <bind name="" val
Mybatis常用分页插件实现快速分页处理技巧

在未分享整个查询分页的执行代码之前,先了解一下执行流程. 1.总体上是利用mybatis的插件拦截器,在sql执行之前拦截,为查询语句加上limit X X 2.用一个Page对象,贯穿整个执行流程,这个Page对象需要用Java编写前端分页组件 3.用一套比较完整的三层entity,dao,service支持这个分页架构 4.这个分页用到的一些辅助类注:分享的内容较多,这边的话我就不把需要的jar一一列举,大家使用这个分页功能的时候缺少什么就去晚上找什么jar包即可,尽可能用maven包导入
详解MyBatis 常用写法

什么是 MyBatis ? MyBatis 是一款优秀的持久层框架,它支持定制化 SQL.存储过程以及高级映射.MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集.MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息,将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录. 1.forEach 循环 forEach 元素的属性主要有 item, idnex, collection,
mybatis foreach标签的使用详解

mybatis的foreach标签经常用于遍历集合,构建in条件语句或者批量操作语句. 下面是foreach标签的各个属性属性描述 collection 表示迭代集合的名称,可以使用@Param注解指定,如下图所示该参数为必选 item 表示本次迭代获取的元素,若collection为List.Set或者数组,则表示其中的元素:若collection为map,则代表key-value的value,该参数为必选 open 表示该语句以什么开始,最常用的是左括弧'(',注意:mybatis会将
MyBatis常用动态sql大总结

简介相信大家没用Mybatis之前,都碰到过各种条件判断拼接SQL.需要去掉多余的逗号等痛苦,Mybatis中的动态SQL能很好的解决上面说的情况,可以很灵活的组装SQL语句,从而提高开发效率. 1.SQL的动态拼接有哪些 if标签 where标签 choose when otherwise标签 set标签 trim标签 bind标签 sql和include标签 foreach标签 2.if标签: test中写判断条件参数直接paramN或者别名特点: 只要成立就拼接在Sql语句中,都成立
mybatis test标签如何判断值是否相等

mybatis test标签判断值是否相等 mybatis可以很方便生成动态sql, 常用的方式如下: <if test="id != null and id !=''"> and id != #{id} </if> 但是在实际使用过程中可能会需要对某个输入的值做具体判断,然后根据输入参数的值进行分支处理 <select id="xxxx" parameterType="map" resultMap="Ba
Mybatis Generator具体使用小技巧

目录 1.问题描述 2.解决方案 2.1 pom中指定mybatis generator 插件 2.2 generatorConfig.xml 2.3 执行 2.4 总结 1.问题描述 mybatis generator 简单说就是生成一些mybatis的公共方法,用了好多年了,一直也没记录过,最近使用稍微有了点变话,简单记录下,方便下次使用,也希望可以帮到其他人. 2.解决方案最近使用主要有两点变化: (1)以前使用,指定了本地数据库驱动jar包,本次直接用maven,dependency指
Mybatis常用注解中的SQL注入实例详解

目录前言常见注入场景 2.1普通注解 2.2 动态sql 2.2.1 使用< script> 2.2.2 使用Provider注解总结前言 MyBatis3提供了新的基于注解的配置.主要在MapperAnnotationBuilder中,定义了相关的注解: public MapperAnnotationBuilder(Configuration configuration, Class<?> type) { ... sqlAnnotationTypes.add(Select
常用SQL语句优化技巧总结【经典】

本文实例总结了常用SQL语句优化技巧.分享给大家供大家参考,具体如下: 除了建立索引之外,保持良好的SQL语句编写习惯将会降低SQL性能问题发生. ①通过变量的方式来设置参数好: stringsql = "select * from people p where p.id = ? "; 坏: stringsql = "select * from people p where p.id = "+id; 数据库的SQL文解析和执行计划会保存在缓存中,但是SQL文只要有

MyBatis常用标签以及使用技巧总结

前言

1、统一的增删改

2、统一的查询

3、统一的增删改查

4、利用IDEA的Code Templates自动生成

5、连接关系表

总结

相关推荐

随机推荐