精华内容
下载资源
问答
  • mybatis的常用动态sql标签

    万次阅读 多人点赞 2019-03-24 17:29:17
    定义 sql 语句 select 标签 属性介绍: id :唯一的标识符. parameterType:传给此语句的参数的全路径名或别名 例:com.test.poso.User 或 user resultType :语句返回值类型或别名。注意,如果是集合,那么这里填写的...

    一. 定义 sql 语句

    select 标签

    属性介绍:

    • id :唯一的标识符.
    • parameterType:传给此语句的参数的全路径名或别名 例:com.test.poso.User 或 user
    • resultType :语句返回值类型或别名。注意,如果是集合,那么这里填写的是集合的泛型,而不是集合本身(resultType 与 resultMap 不能并用)
    <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="Object">
        select * from student where id=#{id}
    </select>
    

    insert 标签

    属性介绍:

    • id :唯一的标识符
    • parameterType:传给此语句的参数的全路径名或别名 例:com.test.poso.User
    <insert id="insert" parameterType="Object">
        insert into student
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="name != null"> NAME, </if>
        </trim>
        <trim prefix="values(" suffix=")" suffixOverrides=",">
            <if test="name != null"> #{name}, </if>
         </trim>
    </insert>
    

    delete 标签

    属性同 insert

    <delete id="deleteByPrimaryKey" parameterType="Object">
        delete from student where id=#{id}
    </delete>
    

    update 标签

    属性同 insert

    二. 配置 JAVA 对象属性与查询结果集中列名对应关系

    resultMap 标签的使用
    基本作用:

    • 建立 SQL 查询结果字段与实体属性的映射关系信息
    • 查询的结果集转换为 java 对象,方便进一步操作。
    • 将结果集中的列与 java 对象中的属性对应起来并将值填充进去

    !注意:与 java 对象对应的列不是数据库中表的列名,而是查询后结果集的列名

    <resultMap id="BaseResultMap" type="com.online.charge.platform.student.model.Student">
        <id property="id" column="id" />
        <result column="NAME" property="name" />
        <result column="HOBBY" property="hobby" />
        <result column="MAJOR" property="major" />
        <result column="BIRTHDAY" property="birthday" />
        <result column="AGE" property="age" />
    </resultMap>
    
    <!--查询时resultMap引用该resultMap -->
    <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="Object">
        select id,name,hobby,major,birthday,age from student where id=#{id}
    </select>
    

    标签说明:

    主标签:

    • id:该 resultMap 的标志
    • type:返回值的类名,此例中返回 Studnet 类

    子标签:

    • id:用于设置主键字段与领域模型属性的映射关系,此处主键为 ID,对应 id。
    • result:用于设置普通字段与领域模型属性的映射关系

    三. 动态 sql 拼接

    if 标签

    if 标签通常用于 WHERE 语句、UPDATE 语句、INSERT 语句中,通过判断参数值来决定是否使用某个查询条件、判断是否更新某一个字段、判断是否插入某个字段的值。

    <if test="name != null and name != ''">
        and NAME = #{name}
    </if>
    

    foreach 标签

    foreach 标签主要用于构建 in 条件,可在 sql 中对集合进行迭代。也常用到批量删除、添加等操作中。

    <!-- in查询所有,不分页 -->
    <select id="selectIn" resultMap="BaseResultMap">
        select name,hobby from student where id in
        <foreach item="item" index="index" collection="list" open="(" separator="," close=")">
            #{item}
        </foreach>
    </select>
    

    属性介绍:

    • collection:collection 属性的值有三个分别是 list、array、map 三种,分别对应的参数类型为:List、数组、map 集合。
    • item :表示在迭代过程中每一个元素的别名
    • index :表示在迭代过程中每次迭代到的位置(下标)
    • open :前缀
    • close :后缀
    • separator :分隔符,表示迭代时每个元素之间以什么分隔

    choose 标签

    有时候我们并不想应用所有的条件,而只是想从多个选项中选择一个。MyBatis 提供了 choose 元素,按顺序判断 when 中的条件出否成立,如果有一个成立,则 choose 结束。当 choose 中所有 when
    的条件都不满则时,则执行 otherwise 中的 sql。类似于 Java 的 switch 语句,choose 为 switch,when 为 case,otherwise 则为 default。

    if 是与(and)的关系,而 choose 是或(or)的关系。

    <select id="getStudentListChoose" parameterType="Student" resultMap="BaseResultMap">
        SELECT * from STUDENT WHERE 1=1
        <where>
            <choose>
                <when test="Name!=null and student!='' ">
                    AND name LIKE CONCAT(CONCAT('%', #{student}),'%')
                </when>
                <when test="hobby!= null and hobby!= '' ">
                    AND hobby = #{hobby}
                </when>
                <otherwise>
                    AND AGE = 15
                </otherwise>
            </choose>
        </where>
    </select>
    

    四. 格式化输出

    where 标签

    当 if 标签较多时,这样的组合可能会导致错误。 如下:

    <select id="getStudentListWhere" parameterType="Object" resultMap="BaseResultMap">
        SELECT * from STUDENT WHERE
        <if test="name!=null and name!='' ">
            NAME LIKE CONCAT(CONCAT('%', #{name}),'%')
        </if>
        <if test="hobby!= null and hobby!= '' ">
            AND hobby = #{hobby}
        </if>
    </select>
    

    当 name 值为 null 时,查询语句会出现 “WHERE AND” 的情况,解决该情况除了将"WHERE"改为“WHERE 1=1”之外,还可以利用 where
    标签。这个“where”标签会知道如果它包含的标签中有返回值的话,它就插入一个‘where’。此外,如果标签返回的内容是以 AND 或 OR 开头的,则它会剔除掉。

    <select id="getStudentListWhere" parameterType="Object" resultMap="BaseResultMap">
        SELECT * from STUDENT
        <where>
            <if test="name!=null and name!='' ">
                NAME LIKE CONCAT(CONCAT('%', #{name}),'%')
            </if>
            <if test="hobby!= null and hobby!= '' ">
                AND hobby = #{hobby}
            </if>
        </where>
    </select>
    

    set 标签

    没有使用 if 标签时,如果有一个参数为 null,都会导致错误。当在 update 语句中使用 if 标签时,如果最后的 if 没有执行,则或导致逗号多余错误。使用 set 标签可以将动态的配置 set
    关键字,和剔除追加到条件末尾的任何不相关的逗号。

    <update id="updateStudent" parameterType="Object">
        UPDATE STUDENT
        SET NAME = #{name},
        MAJOR = #{major},
        HOBBY = #{hobby}
        WHERE ID = #{id};
    </update>
    
    <update id="updateStudent" parameterType="Object">
        UPDATE STUDENT SET
        <if test="name!=null and name!='' ">
            NAME = #{name},
        </if>
        <if test="hobby!=null and hobby!='' ">
            MAJOR = #{major},
        </if>
        <if test="hobby!=null and hobby!='' ">
            HOBBY = #{hobby}
        </if>
        WHERE ID = #{id};
    </update>
    

    使用 set+if 标签修改后,如果某项为 null 则不进行更新,而是保持数据库原值。

    <update id="updateStudent" parameterType="Object">
        UPDATE STUDENT
        <set>
            <if test="name!=null and name!='' ">
                NAME = #{name},
            </if>
            <if test="hobby!=null and hobby!='' ">
                MAJOR = #{major},
            </if>
            <if test="hobby!=null and hobby!='' ">
                HOBBY = #{hobby}
            </if>
        </set>
        WHERE ID = #{id};
    </update>
    

    trim 标签

    格式化输出,也可以通过 trim 标签设定或忽略前后缀来实现,_详见我的另一博客_

    五. 配置关联关系

    5.1 collection 标签

    5.2 association 标签

    _关于关联映射关系,详细参考我的这篇博客_

    六. 定义常量及引用

    sql 标签

    当多种类型的查询语句的查询字段或者查询条件相同时,可以将其定义为常量,方便调用。为求 <select> 结构清晰也可将 sql 语句分解。

    ```
    <!-- 查询字段 -->
    <sql id="Base_Column_List">
        ID,MAJOR,BIRTHDAY,AGE,NAME,HOBBY
    </sql>
    
    <!-- 查询条件 -->
    <sql id="Example_Where_Clause">
        where 1=1
        <trim suffixOverrides=",">
            <if test="id != null and id !=''">
                and id = #{id}
            </if>
            <if test="major != null and major != ''">
                and MAJOR = #{major}
            </if>
            <if test="birthday != null ">
                and BIRTHDAY = #{birthday}
            </if>
            <if test="age != null ">
                and AGE = #{age}
            </if>
            <if test="name != null and name != ''">
                and NAME = #{name}
            </if>
            <if test="hobby != null and hobby != ''">
                and HOBBY = #{hobby}
            </if>
            <if test="sorting != null">
                order by #{sorting}
            </if>
            <if test="sort!= null and sort != ''">
                order by ${sort} ${order}
            </if>
        </trim>
    </sql>
    ```
    

    include 标签

    用于引用定义的常量

    <!-- 查询所有,不分页 -->
    <select id="selectAll" resultMap="BaseResultMap">
        SELECT
        <include refid="Base_Column_List" />
        FROM student
        <include refid="Example_Where_Clause" />
    </select>
    
    
    <!-- 分页查询 -->
    <select id="select" resultMap="BaseResultMap">
        select * from (
            select tt.*,rownum as rowno from
            (
                SELECT
                <include refid="Base_Column_List" />
                FROM student
                <include refid="Example_Where_Clause" />
                ) tt
                <where>
                    <if test="pageNum != null and rows != null">
                        and rownum
                        <![CDATA[<=]]>#{page}*#{rows}
                    </if>
                </where>
            ) table_alias
        where table_alias.rowno>#{pageNum}
    </select>
    
    
    <!-- 根据条件删除 -->
    <delete id="deleteByEntity" parameterType="java.util.Map">
        DELETE FROM student
        <include refid="Example_Where_Clause" />
    </delete>
    
    展开全文
  • mybatis常用动态sql标签主要有以下几种: 标签 作用 if 单条件分支,相当于判断语句 choose、when、otherwise 多条件分支,相当于Java中的switch语句 set、where、trim 辅助条件判断,用于拼接语句 ...

    动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架,你应该能理解根据不同条件拼接 SQL 语句有多痛苦,例如拼接时要确保不能忘记添加必要的空格,还要注意去掉列表最后一个列名的逗号。利用动态 SQL,可以彻底摆脱这种痛苦。

    背景: 我们在编写一些sql查询的过程时,根据条件进行sql的拼接是很麻烦而且容易出错。而mybatis动态sql标签,正好可以解决这个烦人的问题。

    mybatis常用的动态sql标签主要有以下几种:

    标签 作用
    if 单条件分支,相当于判断语句
    choose、when、otherwise 多条件分支,相当于Java中的switch语句
    set、where、trim 辅助条件判断,用于拼接语句
    foreach 集合进行遍历(尤其是在构建 IN 条件语句的时候)
    bind 创建一个变量,并将其绑定到当前的上下文

    1.if

    if 标签最常见情景是根据条件包含 where 子句的一部分,通过判断参数值来决定是否使用某个条件。

    <select id="findUser" resultType="User">
      SELECT * FROM user
      WHERE class = '160801'
      <if test="age != null">
        AND age > #{age}
      </if>
    </select>
    

    2.choose、when、otherwise

    有时候,我们不想使用所有的条件,而只是想从多个条件中选择一个使用。针对这种情况,MyBatis 提供了 choose 元素,它有点像 Java 中的 switch 语句。choose执行过程中按顺序判断 when 中的条件出否成立,如果有一个成立,则 choose 结束。当 choose 中所有 when的条件都不满则时,则执行 otherwise 中的 sql。

    <select id="getUser" resultMap="User">
        SELECT * from STUDENT WHERE 1=1
        <where>
            <choose>
    		    <when test="name!= null">
    		      AND name like #{name}
    		    </when>
    		    <when test="phone != null and address != null">
    		      AND age > #{age}
    		    </when>
    		    <otherwise>
    		      AND featured = 1
    		    </otherwise>
      		</choose>
        </where>
    </select>
    

    3. set、where、trim

    3.1 set

    在 update 语句中使用 if 标签时,如果最后的 if 没有执行,会导致逗号多余错误。使用 set 标签可以动态地在行首插入set关键字,并会删掉额外的逗号(这些逗号是在使用条件语句给列赋值时引入的)。

    
    #如果最后的if没有执行,会导致逗号多余错误。
    
    <update id="updateUser">
      update User SET
          <if test="name != null">
          	name =#{name},
          </if>
          <if test="age != null">
          	age=#{age},
          </if>
          <if test="phone != null">
          	phone =#{phone},
          </if>
          <if test="class != null">
          	class=#{class}
          </if>
      where id=#{id}
    </update>
    
    #set标签除掉条件末尾的逗号
    <update id="updateUser">
      update User 
          <if test="name != null">
          	name=#{name},
          </if>
          <if test="age != null">
          	age=#{age},
          </if>
          <if test="phone != null">
          	phone=#{phone},
          </if>
          <if test="class != null">
          	adress=#{adress}
          </if>
      where class=#{class}
    </update>
    

    3.2 where

    where 标签只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除。这样我们就不用在where后面加一个1=1了

    <select id="findUser" resultType="User">
      SELECT * FROM user
    	<where>
    	    <if test="class != null">
    	         AND class = #{class}
    	    </if>
    	    <if test="phone != null and adress != null">
    	        AND age > #{age}
    	    </if>
      </where>
    </select>
    

    3.3 trim

    set 和 where 其实都是 trim 标签的一种类型, 该两种功能都可以使用 trim 标签进行实现。如果你不满足于where和set实现的功能你就可以使用trim来自定义实现。其中trim有四个主要的属性,分别是:

    • prefix:在sql语句加上前缀
    • suffix:在sql语句加上后缀
    • prefixOverrides:去除指定的前缀内容,比如:prefixOverrides=“AND | OR”,去除sql语句多余的前缀"AND"或者"OR"。
    • suffixOverrides:去除指定的后缀内容,比如:suffixOverrides=",",去除sql语句多余的逗号。

    自定义实现3.1的set,去除update语句后缀多余的逗号

    <update id="updateUser" resultType="User">
    	update user set 
    	<trim  suffixOverrides=",">
    		<if test="class != null">
    	         class = #{class},
    	    </if>
    	    <if test="phone != null and adress != null">
    	        age > #{age},
    	    </if>
    	</trim> 
    	where class=#{class}
    </update>
    

    自定义实现3.2的where,去除where子句前缀多余的AND

    <select id="findUser" resultType="User">
    	select * from user
    	<trim prefix="WHERE" prefixOverrides="AND | OR">
    		<if test="class != null">
    	        AND class = #{class}
    	    </if>
    	    <if test="phone != null and adress != null">
    	        AND age > #{age}
    	    </if>
    	</trim>
    </select>
    

    4.foreach

    在进行批量操作的时候,使用比较多的一个场景就是对集合进行遍历,尤其是在构建 IN 条件语句的时候。

    <select id="findUser" resultType="User">
      SELECT * FROM user
    	where class in
        <foreach item="item" index="index" collection="classList" open="(" separator="," close=")">
            #{item}
        </foreach>
    </select>
    

    foreach中的属性:

    • collection:通常有三种可选的值,List、数组、map 集合,其中list最为常用
    • item :集合项,也就是集合里面的值
    • index :遍历时的索引变量,也就是下标
    • open :前缀
    • close :后缀
    • separator :分隔符,每个值之间用什么分隔符来分割

    5.bind

    bind标签表示在表达式以外创建一个变量,并将其绑定到当前的上下文。

    <select id="queryUser" resultType="User">
      <bind name="pattern" value="'%' + name + '%'" />
      SELECT * FROM user
      WHERE name LIKE #{name}
    </select>
    

    参考文章:mybatis官网文档

    展开全文
  • 先让我们看看mybatis常用标签有哪一些 1.insert,delete,update,...这四个标签不用我多说了定义SQL语句的 2.reusltMap 结果集的一个映射 先简单看一下我的一个例子(这个常用在 结果集的映射和嵌套结果查询) ...

    先让我们看看mybatis常用动态SQL的标签有哪一些

    在这里插入图片描述

    如果mybatis和SSM整合环境不会搭建请看这篇

    https://blog.csdn.net/weixin_44012722/article/details/105242601

    我的数据库建表sql语句
    create table student(
    id int auto_increment PRIMARY KEY ,
    name varchar(20) not null ,
    department varchar(20) not null ,
    sex varchar(10) not null ,
    age int check(age>0) 
    );
    
    create table `group`(
    id int auto_increment PRIMARY KEY ,
    name varchar(255) not null
    );
    
    create table student2group(
    id int auto_increment PRIMARY KEY ,
    stuid int not null,
    groupid int not null
    );
    
    create table evaluate(
    id int auto_increment PRIMARY KEY,
    stuid int not null,
    score int not null 
    );
    
    

    1.insert,delete,update,select

    这四个标签不用我多说了定义SQL语句的
    	注意这几个属性意思:
    		id:
    		resultType:输出结果类型
    		resultMap:输出结果结果映射
    		parameterType:输入接收参数类型
    		parameterMap:输入接收结果映射(一般很少用只有不写对象用Map接收参数的时候用,但是一般不写对象接收参数很难维护的 不能见名知意 可能会给队友后面的接盘侠 喷死)
    

    2.reusltMap ,sql

    结果集的一个映射
    先简单看一下我的一个例子(这个常用在 结果集的映射和嵌套结果查询后面会讲)
    mapper文件
    <resultMap id="BaseResultMap" type="com.example.pojo.Student">
        <id column="id" jdbcType="INTEGER" property="id" />
        <result column="name" jdbcType="VARCHAR" property="name" />
        <result column="department" jdbcType="VARCHAR" property="department" />
        <result column="sex" jdbcType="VARCHAR" property="sex" />
        <result column="age" jdbcType="INTEGER" property="age" />
      </resultMap>
      
      <sql id="Base_Column_List">
        id, `name`, department, sex, age
      </sql>
      
      <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
        select 
        <include refid="Base_Column_List" />
        from student
        where id = #{id,jdbcType=INTEGER}
      </select>
      <!--
    		①resultMap:
    				id:映射对象的主键
    				result  -> column:数据库字段 
    						->jdbcType:数据库类型
    						->property:映射对象的字段变量名
    		②sql:
    			通常是写复用的sql语句,如果有大量相同的sql语句出现可用它装起来
    			在需要此sql语句段地方用<include refid="sql标签的id" />引用即可
    	-->
    
    测试类
    	@Test
        public void test6(){
            //使用元素查询特定id的部分学生信息
            System.out.println("使用元素查询特定id的部分学生信息 :" + studentService.selectByPrimaryKey(3));
        }
    
    控制台结果

    在这里插入图片描述

    3.foreach

    mapper文件
    <select id="selectIDInScope" parameterType="java.util.List" resultType="com.example.pojo.Student">
        select * from student where id in
        <foreach collection="idScope" item="i" open="(" separator="," close=")">
            ${i}
        </foreach>
      </select>
      <!-- 
      		collection:是接收参数的变量名,这个变量可以是一个集合或者数组
    		item:遍历集合或者数组的元素
      		open:开始内容
      		separator:间隔之间的内容
      		close:结束的内容
    	 -->
    
    测试类
    	@Test
        public void test6_1(){
            //使用元素查询特定id的部分学生信息
            System.out.println("使用元素查询特定id的部分学生信息 :");
            studentService.selectIDInScope(Arrays.asList(new Integer [] {1,2,3})).forEach(System.out::println);
        }
    
    控制台结果

    在这里插入图片描述

    4.if , trim

    mapper文件
    <insert id="insertSelective" parameterType="com.example.pojo.Student">
        insert into student
        <trim prefix="(" suffix=")" suffixOverrides=",">
          <if test="id != null">
            id,
          </if>
          <if test="name != null">
            `name`,
          </if>
          <if test="department != null">
            department,
          </if>
          <if test="sex != null">
            sex,
          </if>
          <if test="age != null">
            age,
          </if>
        </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
          <if test="id != null">
            #{id,jdbcType=INTEGER},
          </if>
          <if test="name != null">
            #{name,jdbcType=VARCHAR},
          </if>
          <if test="department != null">
            #{department,jdbcType=VARCHAR},
          </if>
          <if test="sex != null">
            #{sex,jdbcType=VARCHAR},
          </if>
          <if test="age != null">
            #{age,jdbcType=INTEGER},
          </if>
        </trim>
      </insert>
    
    	<!--
    		① if: test 判断语句(条件) 满足条件则加入if标签内的内容
    		② trim:在trim标签内的内容去除空格
    				prefix:开始的内容
    				suffix:结束的内容
    				suffixOverrides:结束内容前要去掉的内容
    	-->
    
    测试类
    	@Test
        public void test10(){
            System.out.println("插入学生");
            Student student = new Student();
            student.setName("树懒");
            student.setDepartment("计算机系");
            student.setSex("男");
            student.setAge(22);
            System.out.println(studentService.insertSelective(student));
        }
    
    结果

    在这里插入图片描述

    5.choose,when,otherwise

    <select id="selectActivityAnd" resultType="com.example.pojo.Student">
        select
        <include refid="Base_Column_List" />
        from student where 1 = 1
        <choose>
          <when test="id != null ">
            and id = #{id}
          </when>
          <when test="name != null and name != ''">
            and name = #{name}
          </when>
          <when test="department != null and department != ''">
            and department = #{department}
          </when>
          <when test="sex != null and sex != ''">
            and sex = #{sex}
          </when>
          <otherwise>
            and age > 20
          </otherwise>
        </choose>
      </select>
    	<!--
    		choose和when以及otherwise要配合使用
    		when: test:判断语句(条件)满足条件则加入when标签内的内容
    		otherwise:choose内的when标签条件都不满足才加入otherwise标签内的内容
    		和 switch case default很像
    		注意:when 和 otherwise 标签内的内容都有一个and 所以要在choose标签的前面加上一个条件 1=1
    	-->
    

    6.where,bind

    mapper文件
    <select id="selectByNameDim" resultType="com.example.pojo.Student">
        <bind name="nameBind" value="'%'+name+'%'"/>
        select
        <include refid="Base_Column_List" />
        from student
        <where>
          <if test="name != null and name != ''">
            name LIKE #{nameBind}
          </if>
        </where>
      </select>
      <!--
      bind标签作用:
      	在进行模糊查询时,如果使用“${}”拼接字符串,则无法防止 SQL 注入问题
      	。如果使用字符串拼接函数或连接符号,但不同数据库的拼接函数或连接
      	符号不同。例如 MySQL 的 concat 函数、Oracle 的连接符号“||”,这样 
      	SQL 映射文件就需要根据不同的数据库提供不同的实现,显然比较麻烦,且不利
      	于代码的移植。幸运的是,MyBatis 提供了 <bind> 元素来解决这一问题。
      	bind -> name:绑定变量名
      		 -> value:绑定的值 里面的name是我接收参数的变量名
      		 是要在想用到的地方#{绑定的变量名}即可
    	where : 相当于给标签内部的内容前面加一个where关键字
    
      -->
    
    测试类
    	@Test
        public void test7(){
            //使用元素模糊查询学生信息
            List<Student> students5 = studentService.selectByNameDim("大");
            students5.forEach(System.out::println);
        }
    
    控制台结果

    在这里插入图片描述

    7.set

    <update id="updateByPrimaryKeySelective" parameterType="com.example.pojo.Student">
        update student
        <set>
          <if test="name != null">
            `name` = #{name,jdbcType=VARCHAR},
          </if>
          <if test="department != null">
            department = #{department,jdbcType=VARCHAR},
          </if>
          <if test="sex != null">
            sex = #{sex,jdbcType=VARCHAR},
          </if>
          <if test="age != null">
            age = #{age,jdbcType=INTEGER},
          </if>
        </set>
        where id = #{id,jdbcType=INTEGER}
      </update>
      <!--
    	set:给set标签内的内容前面加上一个set关键字,where标签作用一样	
    	-->
    
    测试类

    ···java
    @Test
    public void test5(){
    //使用元素实现学生信息的更新
    Student condition4 = new Student();
    System.out.println(“原本数据 :” + studentService.selectByPrimaryKey(1));
    condition4.setId(1);
    condition4.setName(“树懒”);
    studentService.updateByPrimaryKeySelective(condition4);
    System.out.println(“更新后数据 :” + studentService.selectByPrimaryKey(1));
    }
    ···

    控制台结果

    在这里插入图片描述

    8.association(用于一对一关系例如一个学生对应一个评估)

    8.1嵌套查询
    Student类添加一个evaluate成员变量

    在这里插入图片描述

    Student的mapper文件
    <select id="selectStudentAndEvaluate" resultMap="studentEvalateMap">
            select id, name, department, sex, age  from student where id = #{id}
        </select>
        <resultMap id="studentEvalateMap" type="com.example.pojo.Student">
            <id column="id" property="id"/>
            <result column="name" property="name"/>
            <result column="department" property="department"/>
            <result column="sex" property="sex"/>
            <result column="age" property="age"/>
            <association property="evaluate" column="id" javaType="com.example.pojo.Evaluate" select="com.example.dao.EvaluateDao.selectByStuid" />
        </resultMap>
        <!--
        	association :
        		property:映射对象的成员变量的变量名
        		column:传给select查询语句的值
        		javaType:此关联查询对象的java类型
        		select:关联查询
    	-->
    
    Evaluate的mapper文件
    	<select id="selectByStuid" resultType="com.example.pojo.Evaluate">
          select id, score, stuid from evaluate where stuid = #{stuid}
        </select>
    
    测试类
        @Test
        public void test11(){
            System.out.println("association 嵌套查询");
            System.out.println(studentService.selectStudentAndEvaluate(1));
        }
    
    控制台结果

    在这里插入图片描述

    8.2嵌套结果
    Student的mapper文件
    <select id="selectStudentAndEvaluate2" resultMap="studentEvalateMap2">
            select s.id,name,department,sex,age,e.id as eid,stuid,score from student s inner join evaluate e on s.id = e.stuid where s.id = #{id}
        </select>
        <resultMap id="studentEvalateMap2" type="com.example.pojo.Student">
            <id column="id" property="id"/>
            <result column="name" property="name"/>
            <result column="department" property="department"/>
            <result column="sex" property="sex"/>
            <result column="age" property="age"/>
            <association property="evaluate" javaType="com.example.pojo.Evaluate">
                <id column="eid" property="id"/>
                <result column="stuid" property="stuid"/>
                <result column="score" property="score"/>
            </association>
        </resultMap>
        <!--
        	association :
        		property:映射对象的成员变量的变量名
        		javaType:此关联查询对象的java类型
    	-->
    
    测试类
    	@Test
        public void test12(){
            System.out.println("association 嵌套结果");
            System.out.println(studentService.selectStudentAndEvaluate2(1));
        }
    
    控制台的结果

    在这里插入图片描述

    9.collection(用于一对多关系例如一个学生对应多个群组)

    9.1嵌套查询
    Student类添加一个groups成员变量

    在这里插入图片描述

    Student的mapper文件
    <select id="selectStudentAndGroup" resultMap="findGroupResult">
            select id,name,department,sex,age from student where id = #{id};
        </select>
        <resultMap id="findGroupResult" type="com.example.pojo.Student">
            <id column="id" property="id" />
            <result column="name" property="name" />
            <result column="department" property="department" />
            <result column="sex" property="sex" />
            <result column="age" property="age" />
            <collection property="groups" ofType="com.example.pojo.Group" column="id" select="com.example.dao.GroupDao.findGroup"/>
        </resultMap>
        <!--
        	collection:
        		property:映射对象的成员变量的变量名
        		column:传给select查询语句的值
        		ofType:此关联查询对象的java类型
        		select:关联查询
        -->
    
    Group的mapper文件
    <select id="findGroup" resultType="com.example.pojo.Group">
          select id,name from `group` where id in ( select groupid from student2group where stuid = #{id} )
       </select>
    
    测试类
    	@Test
        public void test8(){
            System.out.println("collection 嵌套查询");
            System.out.println(studentService.selectStudentAndGroup(1));
        }
    
    控制台的结果

    在这里插入图片描述

    9.2嵌套结果
    Student的mapper文件
    <select id="selectStudentAndGroup2" resultMap="studentMap">
        select s.id,s.`name`,department,sex,age,g.id as gid,g.`name` as gname from student s inner join student2group ss on s.id = ss.stuid inner join `group` g on ss.groupid = g.id where s.id = #{id}
      </select>
        <resultMap id="studentMap" type="com.example.pojo.Student">
        <id column="id" property="id" />
        <result column="name" property="name" />
        <result column="department" property="department" />
        <result column="sex" property="sex" />
        <result column="age" property="age" />
            <collection property="groups" ofType="com.example.pojo.Group">
                <id column="gid" property="id" />
                <result column="gname" property="name" /> 
            </collection>
      </resultMap>
      <!--
        	collection:
        		property:映射对象的成员变量的变量名
        		ofType:此关联查询对象的java类型
        -->
    
    测试类
    	@Test
        public void test9(){
            System.out.println("collection 嵌套结果");
            System.out.println(studentService.selectStudentAndGroup2(1));
        }
    

    控制台结果

    在这里插入图片描述

    总结

    association是对一对一关系的关联查询

    collection是对一对多关系的关联查询

    他们用法属性相似 区别就在association的一个属性是javaType而collection的是ofType

    对于多对多关系 Mybatis把它当做一对多来处理 所以不要过于追究。
    关联查询又分为 嵌套结果 和 嵌套查询
    从上面的例子可以看出 嵌套查询 是 拿着第一个SQL语句查询到的 字段 去作为查询条件执行第二个SQL语句 所以它是要经过两次SQL语句查询的
    而 嵌套结果 是通过一个 连接表查询的SQL语句 把查询的结果字段 根据映射关系映射的结果集所以只用经过一个SQL语句查询
    所以 嵌套查询 如果是数据库数据量大的不推荐使用 会拉低访问性能

    10.插入数据返回主键

    在这里插入图片描述使用这三个属性,插入完成后将主键放入对象中

    展开全文
  • Mybatis的动态sql标签

    2017-07-05 17:04:02
    常用动态SQL标签有:if、where、foreach; If标签:作为判断入参来使用的,如果符合条件,则把if标签体内的SQL拼接上。 注意:用if进行判断是否为空时,不仅要判断null,也要判断空字符串‘’; Where标签:会去掉...

    动态SQL

    通过Mybatis提供的各种动态标签实现动态拼接sql,使得mapper映射文件在编写SQL时更加灵活,方便。常用动态SQL标签有:if、where、foreach;

    1. If标签:作为判断入参来使用的,如果符合条件,则把if标签体内的SQL拼接上。
      注意:用if进行判断是否为空时,不仅要判断null,也要判断空字符串‘’;
      Where标签:会去掉条件中的第一个and符号。
    2. Foreach
      向sql传递数组或List时,mybatis使用foreach解析数组里的参数并拼接到SQL中。3
    3. SQL片段
      Mybatis提供了SQL片段的功能,可以提高SQL的可重用性。
    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 464
精华内容 185
关键字:

常用动态sql标签