mybatis 使用动态SQL

RoleMapper.java

public interface RoleMapper {

    public void add(Role role);

    public void update(Role role);

    public void delete(Role role);

    public List<Role> getRoleList(Role role);
}

RoleMapper.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="cn.bdqn.dao.RoleMapper">
    <!-- where/if(判断参数) - 将实体类不为空的属性作为where条件, 能智能的处理 and or ,不必担心多余导致语法错误-->
    <!-- <select id="getRoleList" resultType="Role" parameterType="Role">
        select * from role
        <where>
            <if test="roleCode != null">
                and roleCode like CONCAT (‘%‘,#{roleCode},‘%‘)
            </if>
            <if test="roleName != null">
                and roleName like CONCAT (‘%‘,#{roleName},‘%‘)
            </if>
        </where>
    </select> -->

    <!-- if/trim代替where(判断参数) - 将实体类不为空的属性作为where条件 -->
   <!--  <select id="getRoleList" resultType="Role" parameterType="Role">
        select * from role
        <trim prefix="where" prefixOverrides="and | or">
            <if test="roleCode != null">
                and roleCode like CONCAT (‘%‘,#{roleCode},‘%‘)
            </if>
            <if test="roleName != null">
                and roleName like CONCAT (‘%‘,#{roleName},‘%‘)
            </if>
        </trim>
    </select> -->

    <!-- choose(判断参数) - 按顺序将实体类第一个不为空的属性作为where条件 -->
     <select id="getRoleList" resultType="Role" parameterType="Role">
         select * from role
         <where>
             <choose>
                 <when test="roleCode != null">
                     and roleCode like CONCAT (‘%‘,#{roleCode},‘%‘)
                 </when>
                 <when test="roleName != null">
                     and roleName like CONCAT (‘%‘,#{roleName},‘%‘)
                 </when>
                 <otherwise></otherwise>
             </choose>
         </where>
     </select>

    <insert id="add" parameterType="Role">
        insert into role (roleCode,roleName)
            values (#{roleCode},#{roleName})
    </insert>

    <update id="update" parameterType="Role">
        update role set roleCode=#{roleCode},roleName=#{roleName}
            where id=#{id}
    </update>

    <delete id="delete" parameterType="Role">
        delete from role where id=#{id}
    </delete>

</mapper>

UserMapper.java

public interface UserMapper {

    public int count();

    public void add(User user);

    public void update(User user);

    public void delete(User user);

    public List<User> getUserList();

    //根据roleId获取用户列表
    public List<User> getUserListByRoleId(Role role);

    //获取指定用户的地址列表(user表-address表：1对多关系)
    public User getAddressListByUserId(User user);

    //根据条件，获取用户表数据列表(动态sql)
    public List<User> searchUserList(User user);

    //根据部门条件，获取用户表数据列表-foreach_array
    public List<User> getUserByDepId_foreach_array(String[] depIds);

    //根据部门条件,获取用户表数据列表-foreach_list
    public List<User> getUserByDepId_foreach_list(List<String> depIdList);

}

UserMapper.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">

<!-- namespace的名字需要跟接口的类名一致 -->
<mapper namespace="cn.bdqn.dao.UserMapper">
    <!--
    1、resultMap属性：type为java实体类；id为此resultMap的标识
    2、resultMap的子元素：
        id – 一般对应到数据库中该行的ID,设置此项可以提高Mybatis性能.
        result – 映射到JavaBean 的某个“简单类型”属性,String,int等.
        association – 映射到JavaBean 的某个“复杂类型”属性,其他JavaBean类.
        collection –复杂类型集合
     -->

    <!--根据roleId获取用户列表: 当数据库中的字段信息与对象的属性不一致时需要通过resultMap来映射 -->
    <!-- <resultMap type="User" id="seachUserResult">
        <result property="id" column="id"/>
        <result property="userCode" column="userCode"/>
        <result property="userName" column="userName"/>
        <result property="roleId" column="roleId"/>
        <result property="roleName" column="roleName"/>
    </resultMap>

    <select id="getUserListByRoleId" parameterType="Role" resultMap="seachUserResult">
        select u.*,r.roleName as roleName from user u,role r where u.roleId = r.id and u.roleId = #{id}
    </select> -->

    <!-- 根据roleId获取用户列表 association start-->
    <resultMap type="User" id="seachUserResult">
        <result property="id" column="id"/>
        <result property="userCode" column="userCode" />
        <result property="userName" column="userName" />
        <result property="roleId" column="roleId" />
        <!-- <association property="role" javaType="Role" >
            <result property="id" column="id"/>
            <result property="roleCode" column="roleCode"/>
            <result property="roleName" column="roleName"/>
        </association> -->
        <association property="role" javaType="Role" resultMap="roleMap"/>
    </resultMap>

    <resultMap type="Role" id="roleMap">
        <result property="id" column="id"/>
        <result property="roleCode" column="roleCode"/>
        <result property="roleName" column="roleName"/>
    </resultMap>

    <select id="getUserListByRoleId" parameterType="Role" resultMap="seachUserResult">
        select u.*,r.roleCode as roleCode,r.roleName as roleName from user u,role r where u.roleId = r.id and u.roleId = #{id}
    </select>

    <!-- association end-->

    <!-- 获取指定用户的地址列表(user表-address表：1对多关系) collection start-->
    <resultMap type="User" id="userMap">
        <id property="id" column="userId"/>
        <collection property="addressList" ofType="Address">
            <id property="id" column="a_id"/>
            <result property="postCode" column="postCode"/>
            <result property="addressContent" column="addressContent"/>
        </collection>
    </resultMap>

    <select id="getAddressListByUserId" parameterType="User" resultMap="userMap">
        select *,a.id as a_id from user u,address a where u.id=a.userId and u.id=#{id}
    </select>
    <!-- collection end -->

    <resultMap type="User" id="seachUser">
        <result property="id" column="id"/>
        <result property="userCode" column="userCode"/>
        <result property="userName" column="userName"/>
        <result property="roleId" column="roleId"/>
        <result property="roleName" column="roleName"/>
    </resultMap>

    <!-- <select id="searchUserList" parameterType="User" resultMap="seachUser">
        select u.*,r.roleName as roleName from user u,role r where u.roleId = r.id
            and u.roleId = #{roleId}
            and u.userCode like CONCAT (‘%‘,#{userCode},‘%‘)
            and u.userName like CONCAT (‘%‘,#{userName},‘%‘)
    </select> -->

    <!--
    1、有些时候，sql语句where条件中，需要一些安全判断，例如按性别检索，如果传入的参数是空的，此时查询出的结果很可能是空的，也许我们需要参数为空时，是查出全部的信息。这是我们可以使用动态sql，增加一个判断，当参数不符合要求的时候，我们可以不去判断此查询条件。
    2、mybatis 的动态sql语句是基于OGNL表达式的。可以方便的在 sql 语句中实现某些逻辑. 总体说来mybatis 动态SQL 语句主要有以下几类:
        if 语句 (简单的条件判断)
        choose (when,otherwize) ,相当于java 语言中的 switch ,与 jstl 中的choose 很类似.
        trim (对包含的内容加上 prefix,或者 suffix 等，前缀，后缀)
        where (主要是用来简化sql语句中where条件判断的，能智能的处理 and or ,不必担心多余导致语法错误)
        set (主要用于更新时)
        foreach (在实现 mybatis in 语句查询时特别有用)
     -->

    <!--  if(判断参数) - 将实体类不为空的属性作为where条件 -->
    <select id="searchUserList" parameterType="User" resultMap="seachUser">
        select u.*,r.roleName as roleName from user u,role r where u.roleId = r.id
            <if test="roleId!=null">
                and u.roleId = #{roleId}
            </if>
            <if test="userCode != null">
                and u.userCode like CONCAT (‘%‘,#{userCode},‘%‘)
            </if>
            <if test="userName != null">
                and u.userName like CONCAT (‘%‘,#{userName},‘%‘)
            </if>
    </select>

    <select id="count" resultType="int">
        select count(1) from user
    </select>

    <insert id="add" parameterType="User">
        insert into user (userCode,userName,userPassword)
            values (#{userCode},#{userName},#{userPassword})
    </insert>

    <!-- if/set(判断参数) - 将实体类不为空的属性更新 -->
    <!-- <update id="update" parameterType="User">
        update user
            <set>
                <if test="userCode != null and userCode != ‘‘">userCode=#{userCode},</if>
                <if test="userName != null">userName=#{userName},</if>
                <if test="userPassword != null">userPassword=#{userPassword},</if>
                <if test="roleId != null">roleId=#{roleId}</if>
            </set>
            where id=#{id}
    </update> -->

    <!-- if/trim代替set(判断参数) - 将实体类不为空的属性更新 -->
    <update id="update" parameterType="User">
        update user
         <trim prefix="set" suffixOverrides=",">
             <if test="userCode != null and userCode != ‘‘">userCode=#{userCode},</if>
            <if test="userName != null">userName=#{userName},</if>
            <if test="userPassword != null">userPassword=#{userPassword},</if>
            <if test="roleId != null">roleId=#{roleId}</if>
         </trim>
         where id=#{id}
    </update>

    <!--注意： 你可以传递一个List实例或者数组作为参数对象传给MyBatis。
              当你这么做的时候，MyBatis会自动将它包装在一个Map中，用名称在作为键。
          List实例将会以“list”作为键，而数组实例将会以“array”作为键。
                      配置文件中的parameterType是可以不配置的-->
    <resultMap type="User" id="userMapByDep">
        <result property="id" column="id"/>
        <result property="userCode" column="userCode"/>
        <result property="userName" column="userName"/>
    </resultMap>
    <!-- foreach(循环array参数) - 作为where中in的条件 -->
    <select id="getUserByDepId_foreach_array" resultMap="userMapByDep">
        select * from user  where depId in
            <foreach collection="array" item="depIds" open="(" separator="," close=")">
                #{depIds}
            </foreach>
    </select>

    <!-- foreach(循环List<String>参数) - 作为where中in的条件 -->
    <select id="getUserByDepId_foreach_list" resultMap="userMapByDep">
        select * from user  where depId in
            <foreach collection="list" item="depIdList" open="(" separator="," close=")">
                #{depIdList}
            </foreach>
    </select>

    <delete id="delete" parameterType="User">
        delete from user where id=#{id}
    </delete>

    <select id="getUserList" resultType="User">
        select * from user
    </select>
</mapper>
时间： 2024-10-13 12:16:42

mybatis 使用动态SQL的相关文章

MyBatis的动态SQL详解

MyBatis的动态SQL是基于OGNL表达式的,它可以帮助我们方便的在SQL语句中实现某些逻辑,本文详解mybatis的动态sql,需要的朋友可以参考下 MyBatis 的一个强大的特性之一通常是它的动态 SQL 能力.如果你有使用 JDBC 或其他 相似框架的经验,你就明白条件地串联 SQL 字符串在一起是多么的痛苦,确保不能忘了空 格或在列表的最后省略逗号.动态 SQL 可以彻底处理这种痛苦. 通常使用动态SQL不可能是独立的一部分,MyBatis当然使用一种强大的动态SQL语言来改进这种

Mybatis的动态Sql

基础部分可以查看我的另一篇博客:http://blog.csdn.net/elim168/article/details/40622491 MyBatis的动态SQL是基于OGNL表达式的,它可以帮助我们方便的在SQL语句中实现某些逻辑. MyBatis中用于实现动态SQL的元素主要有: if choose(when,otherwise) trim where set foreach if就是简单的条件判断,利用if语句我们可以实现某些简单的条件选择.先来看如下一个例子: Xml代码 <sele

MyBatis中动态SQL语句完成多条件查询

http://blog.csdn.net/yanggaosheng/article/details/46685565 MyBatis中动态SQL语句完成多条件查询 <select id="queryEmp"  resultType="cn.test.entity.Emp"> select * from emp where 1=1 <if test="deptNo!=null"> and deptno=#{deptNO} &

MyBatis 构造动态 SQL 语句

以前看过一个本书叫<深入浅出 MFC >,台湾 C++ 大师写的一本书.在该书中写道这样一句话,"勿在浮沙筑高台",这句话写的的确对啊.编程很多语言虽然相同,但是真正做还是需要认真的学习,如果只是想着按想像着来,真的是会走很多弯路,浪费很多时间. 无法使用 not in 在项目中需要使用到 not in ,想着不是很复杂,但是这个问题困扰了我个把小时,很是郁闷.自己拼接好了字符串,字符串的内容是 not in 中的各个 id 值.通过 not in 来进行 update 的

MyBatis探究-----动态SQL详解

1.if标签 接口中方法:public List<Employee> getEmpsByEmpProperties(Employee employee); XML中:where 1=1必不可少 <select id="getEmpsByEmpProperties" resultType="com.mybatis.entity.Employee"> select * from t_employee where 1=1 <if test=&

Mybatis系列---动态SQL

问题: 什么是动态SQL? 动态SQL有什么作用? 传统的使用JDBC的方法,相信大家在组合复杂的的SQL语句的时候,需要去拼接,稍不注意哪怕少了个空格,都会导致错误.Mybatis的动态SQL功能正是为了解决这种问题, 其通过 if, choose, when, otherwise, trim, where, set, foreach,可组合成非常灵活的SQL语句,从而提高开发人员的效率. 下述可知道这四个操作节点中的子节点都是差不多是一样的,insert和update中多了一个selectK

一分钟带你了解下MyBatis的动态SQL！

MyBatis的强大特性之一便是它的动态SQL,以前拼接的时候需要注意的空格.列表最后的逗号等,现在都可以不用手动处理了,MyBatis采用功能强大的基于OGNL的表达式来实现,下面主要介绍下. 一.if标签 if是最常用的判断语句,主要用于实现某些简单的条件选择.基本使用示例如下: <select id="queryAllUsersByName" resultType="com.example.springboot.mybatisxml.entity.User&quo

Mybatis的动态sql拼接语句

Mybatis的动态sql拼接语句 1.主配置文件SqlMapConfig.xml  <?xml version="1.0" encoding="utf-8" ?> <!DOCTYPE configuration         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"         "http://mybatis.org/dtd/mybatis-3-config.dtd

mybatis入门-动态sql

什么是动态sql 判断的动态sql mybatis核心就是对sql语句进行灵活操作,通过表达式进行判断,对sql进行灵活拼接.组装. 现有需求如下:需要查询用户,输入的是用户类,如果用户的性别类不为空,则将性别作为查询条件之一,如果用户的姓名不为空,则将用户姓名作为查询条件之一.如果用户两个属性都为空,则查询所有用户. 我们知道,在mapper中,我们的传入参数只有一个,多个参数只能通过包转类来实现,现在这种问题怎么解决呢?答案就是在xml文件中加入判断,使sql语句动态生成.刚才的需求所对应的