动态SQL整体

已于 2022-05-15 17:22:19 修改
阅读量279 收藏
点赞数
分类专栏： SSM 文章标签： java 开发语言
于 2022-05-14 19:47:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59102081/article/details/124772941
版权

接口UserMapper

package com.wzx.mapper;

import com.wzx.pojo.Users;
import org.apache.ibatis.annotations.Param;

import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 数据访问层的接口，规定数据库中可进行的各种操作
 */
public interface UserMapper {
    //查询去拿不用户信息
    List<Users> getAll();

    //根据用户主键查用户
    Users getById(Integer id);

    //根据用户名模糊查询用户
    List<Users> getByName(String name);

    //用户的更新
    int update(Users users);

    //根据主键删除用户
    int delete(Integer id);

    //增加用户
    int insert(Users users);

    //模糊用户名和地址查询
    List<Users> getByNameOrAddress(
            @Param("columnName") String columnName,
            @Param("columnValue") String columnValue);

    //按照指定的条件进行多条件查询
    List<Users> getByCondition(Users users);
    //有选择的更新
    int updateBySet(Users users);
    //查询多个指定id的用户信息
    List<Users> getByIds(Integer []arr);
    //批量删除
    int deleteBatch(Integer []arr);
    //批量增加
    int insertBatch(List<Users> list);
    //查询指定日期范围内的用户
    List<Users> getByBirthday(Date begin, Date end);
    //入参是map
    List<Users> getByMap(Map map);
    //返回值是map(一行)
    Map getReturnMap(Integer id);
    //返回值是map(多行)
    List<Map> getMulMap();
}

UserMapperxml

<?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="com.wzx.mapper.UserMapper">
    <!--    定义代码片段-->
    <sql id="allColumns">
        id,
        username,
        birthday,
        sex,
        address
    </sql>


    <select id="getAll" resultType="users">
        select
        <include refid="allColumns">
        </include>
        from users
    </select>
    <!--     private Integer id;
        private String userName;
        private Date birthday;
        private String sex;
        private String address;-->
    <update id="update" parameterType="users">
        update users
        set username=#{userName},
            birthday=#{birthday},
            sex#{sex},
            address#{address}
        where id = #{id}
    </update>
    <select id="getById" parameterType="int" resultType="users">
        select
        <include refid="allColumns">
        </include>
        from users
        where id = #{id}
    </select>
    <select id="getByName" parameterType="string" resultType="users">
        select
        <include refid="allColumns">
        </include>
        from users
        where username like '%${userName}%'
    </select>
    <delete id="delete" parameterType="users">
        delete
        from users
        where id = #{id}
    </delete>
    <insert id="insert" parameterType="users">
        insert into (id,username,birthday,sex,address) values (#{id},#{userName},
                #{birthday},
                #{sex},
                #{address} )
    </insert>
    <!--    如果参数超过一个则parameterType不写
            模糊用户名和地址查询
              List<Users> getByNameOrAddress(
              @Param("columnName")String columnName,
              @Param("columnValue")String columnValue);
    -->
    <select id="getByNameOrAddress" resultType="users">
        select
        <include refid="allColumns">
        </include>
        from users
        where ${columnName} like concat('%', #{columnValue}, '%')
    </select>
    <!--     //按照指定的条件进行多条件查询
        List<Users> getByCondition(Users users);
        根据实体类中的成员变量是否有值来决定是否添加条件
    private Integer id;                         0
    private String userName;                    null   or  ""
    private Date birthday;                      null
    private String sex;                         null
    private String address;                     null

        -->
    <select id="getByCondition" parameterType="users" resultType="users">
        select
        <include refid="allColumns">
        </include>
        from users
        <where>
            <if test="userName != null and userName != ''">
                and username like concat('%', #{userName}, '%')
            </if>
            <if test="birthday != null">
                and birthday = #{birthday}
            </if>
            <if test="sex != null and sex != ''">
                and sex = #{sex}
            </if>
            <if test="address != null and address != ''">
                and address like concat('%', #{address}, '%')
            </if>
        </where>
    </select>
    <update id="updateBySet" parameterType="users">
        update users
        <set>
            <if test="userName != null and userName != ''">
                username=#{userName},
            </if>
            <if test="birthday != null">
                birthday=#{birthday},
            </if>
            <if test="sex != null and sex != ''">
                sex=#{sex},
            </if>
            <if test="address != null and address != ''">
                address=#{address}
            </if>
        </set>
        where id = #{id}
    </update>
    <!--//查询多个指定id的用户信息
        List<Users> getByIds(Integer []arr);-->
    <select id="getByIds" resultType="users">
        select
        <include refid="allColumns">
        </include>
        from users
                where id in
        <!--
        collection:用来指定入参的类型,如果是List集合,则为list,如果是Map集合,则为map,如果是数组,则为array.
        item:每次循环遍历出来的值或对象
        separator:多个值或对象或语句之间的分隔符
        open:整个循环外面的前括号
        close:整个循环外面的后括号
               -->
        <foreach collection="array" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </select>
    <!--//批量删除
        int deleteBatch(Integer []arr);-->
    <delete id="deleteBatch">
        delete
        from users
                where id in
        <foreach collection="array" item="id" separator="," open="(" close=")">
            #{id}
        </foreach>
    </delete>
    <!--     //批量增加
        int insertBatch(List<Users> list);
    private Integer id;                         0
    private String userName;                    null   or  ""
    private Date birthday;                      null
    private String sex;                         null
    private String address;                     null
        -->
    <insert id="insertBatch">
        insert into users(username, birthday, sex, address)
                values
        <foreach collection="list" item="u" separator=",">
            (#{u.userName}, #{u.birthday}, #{u.sex}, #{u.address})
        </foreach>
    </insert>
    <!--
       //查询指定日期范围内的用户
        List<Users> getByBirthday(Date begin,Date end);
    -->
    <select id="getByBirthday" resultType="users">
        select
        <include refid="allColumns">
        </include>
        from users
        where birthday between #{arg0} and #{arg1}
    </select>

    <!--
          //入参是map
        List<Users> getByMap(Map map);
    -->
    <select id="getByMap" resultType="users">
        select
        <include refid="allColumns">
        </include>
        from users
        where birthday between #{birthdayBegin} and #{birthdayEnd}
    </select>

    <!--
     //返回值是map(一行)
        Map getReturnMap(Integer id);
    -->
    <select id="getReturnMap" resultType="map">
        select username, address
        from users
        where id = #{id}
    </select>
    <!--
     //返回值是map(多行)
        List<Map> getMulMap();
    -->
    <select id="getMulMap" resultType="map">
     select   username,address
     from users
    </select>
</mapper>

测试类

package com.wzx;

import com.wzx.mapper.UserMapper;
import com.wzx.pojo.Users;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

public class MyTest {

    SqlSession sqlSession;
    UserMapper mapper;
    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");

    @Before
    public void openSqlSession() throws IOException {
        //读取核心配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //创建SqlSessionFactory对象
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //取出SqlSession对象
        sqlSession = factory.openSession();
        //取出动态代理的对象，完成接口中方法的调用，实则是使用xml文件中的标签的功能
        mapper = sqlSession.getMapper(UserMapper.class);
    }

    @After
    public void closeSqlSession() {
        sqlSession.close();
    }

    @Test
    public void testGetAll() {
        //  就是在调用接口的方法，mybatis框架已经为我们把功能代理出来了
        List<Users> list = mapper.getAll();
        System.out.println(list);
        list.forEach(users -> System.out.println(users));
    }

    @Test
    public void testupdate() throws ParseException {
        Users u = new Users(7, "wzx", sf.parse("2001-01-01"), "2", "asd");
        int update = mapper.update(u);
        System.out.println(update);
        sqlSession.commit();

    }

    @Test
    public void selectById() {
        Users byId = mapper.getById(7);
        System.out.println(byId);

    }
    @Test
    public void getByName(){
        List<Users> name = mapper.getByName("张");
        name.forEach(users -> System.out.println(users));
    }
    @Test
    public void delete(){
        int delete = mapper.delete(7);
        System.out.println(delete);
        sqlSession.commit();
    }
    @Test
    public void insert() throws ParseException {
        Users users = new Users(8, "asd", sf.parse("2022-11-22"), "1", "asd");
        int insert = mapper.insert(users);
        System.out.println(insert);
        sqlSession.commit();
    }
    @Test
    public void testGetByCondition(){
        Users users = new Users();
//        users.setSex("1");
//        users.setUserName("小");
//        users.setAddress("南");
        List<Users> list=mapper.getByCondition(users);
        list.forEach(useruser -> System.out.println(useruser));
        for (Users users1 : list) {
            System.out.println(users1);
        }
    }
    @Test
    public void testUpdateSet(){
        Users users = new Users();
        users.setId(6);
        users.setUserName("lla");
        int update = mapper.updateBySet(users);
        System.out.println(update);
        sqlSession.commit();
    }
    @Test
    public void testGetByIds(){
        Integer []array={2,4,6};
        List<Users> byIds = mapper.getByIds(array);
        byIds.forEach(userss -> System.out.println(userss));
    }
    @Test
    public void testDeleteBatch(){
        Integer []array={2,4};
        int i = mapper.deleteBatch(array);
        sqlSession.commit();
        System.out.println(i);
    }
    @Test
    public void testInsertBatch() throws ParseException {
        Users u1 = new Users("aa", sf.parse("2002-02-02"), "2", "朝阳1");
        Users u2 = new Users("bb", sf.parse("2002-02-02"), "2", "朝阳2");
        Users u3 = new Users("cc", sf.parse("2002-02-02"), "2", "朝阳3");
        Users u4 = new Users("dd", sf.parse("2002-02-02"), "2", "朝阳4");
        List<Users> list=new ArrayList<>();
        list.add(u1);
        list.add(u2);
        list.add(u3);
        list.add(u4);
        int i = mapper.insertBatch(list);
        sqlSession.commit();
        System.out.println(i);

    }
    @Test
    public void testGetBirthday() throws ParseException {
        Date begin = sf.parse("1999-01-01");
        Date end = sf.parse("2001-12-31");
        List<Users> list = mapper.getByBirthday(begin,end);
        list.forEach(userss -> System.out.println(userss));
    }
    @Test
    public void testGetMap() throws ParseException {
        Date begin=sf.parse("1999-01-01");
        Date end=sf.parse("1999-12-31");
        Map map = new HashMap<>() ;
        map.put("birthdayBegin",begin);
        map.put("birthdayEnd",end);
        List<Users> list=mapper.getByMap(map);
    }
    @Test
    public void testgetReturnMap(){
        Map returnMap = mapper.getReturnMap(3);
        System.out.println(returnMap);
    }
    @Test
    public void testgetMulMap(){
        List<Map> map = mapper.getMulMap();
        map.forEach(map1 -> System.out.println(map1));
    }
}

懒起来
关注
专栏目录
Mybatis动态 sql用法
m0_70626478的博客
08-12 776
根据不同条件拼接sql语句，实现对数据库的精准操作。
efcore 有值才加where_SSM框架（五）：mybatis中if、where、forecah标签和mybatis连接池...
weixin_39654245的博客
11-28 377
mybatis中if、where、forecah标签的使用1、if标签 在IUserDao.xml加标签，在IUserDao.java和MybatisTest.java加方法 <!-- if 标签的使用--> <select id="findUserByCondition" parameterType="user" resultMap="userMap"> ...
mybatis中if判断为0无效
ITzhongzi的博客
08-13 868
mybatis中if判断为0无效
mybatis if test 之 0当做参数传入出问题
Amelia_Liu的博客
09-22 3618
首先前端传入了参数 if(StringUtils.isNotBlank(status)){ requestParam.setProperty("status", Integer.parseInt(status)); } List applicationList = groupDao.getApplicationListByReviewStat
Mybatis中sql语句中的in查询，判断null和size为0的情况
lppl010_的专栏
04-21 1090
https://www.cnblogs.com/xujanus/p/7611401.html 不严谨的写法，可能会报错：in ()，这种情况不符合SQL的语法，导致程序报错。 如果简单只做非空判断，这样也有可能会有问题：本来in一个空列表，应该是没有数据才对，却变成了获取全部数据！ 所以一个比较周全的方法是： 1 2 3 4 5 ...
什么是mybatis动态sql以及学习mybatis动态sql的意义
最新发布
04-28
例如，在构建复杂的多表查询时，可以通过动态添加或删除JOIN子句来优化查询逻辑，减少不必要的数据加载，从而显著提升应用程序的整体性能。 #### 增强代码的可维护性和扩展性 使用动态SQL可以减少硬编码SQL的数量，...
MySQL存储过程中实现执行动态SQL语句的方法
12-15
动态SQL语句是指在运行时根据需要构建和执行的SQL语句，它允许我们根据不同的条件或参数来执行不同的查询。在存储过程中使用动态SQL语句能够增加代码的灵活性和可维护性。 以下是一个实例，展示了如何在MySQL存储...
### MyBatis动态SQL介绍说明、使用技巧和优缺点
04-28
### MyBatis动态SQL介绍说明、使用技巧和优缺点 #### 一、MyBatis动态SQL简介 MyBatis作为一款出色的持久层...对于开发人员而言，熟练掌握MyBatis动态SQL的相关技术不仅可以提高工作效率，还能提升项目的整体质量。
MyBatis的动态SQL实现原理.pdf
04-28
### MyBatis动态SQL实现原理 #### 一、XML文档中的节点概念 在深入了解MyBatis如何支持SQL语句之前，我们首先需要了解XML文档的基本构成单元——节点。XML是一种非常灵活的数据格式，用于存储和传输数据。XML文档...
mybatis 动态标签详解
qq_45376284的博客
05-11 1万+
if 标签 if标签中有一个test属性，test属性值是一个符合OGNL要求的判断表达式，表达式的结果可以使true或者false， 除此之外所有的非0值都为true （1）、数字类型 1.1 例如： 如果参数为数字类型的时候没有特俗需求的情况只需要判断是否为null即可。 <if test="id != null"></if> 1.2 例如：如果有特俗需求，例如判断是否大于某个数的时候才行。只需要加上对应的条件判断即可。 <if test='id != null an
Mybatis学习笔记（三）
m0_53737524的博客
05-07 517
动态sql引入 (81条消息) 动态SQL_陈伟chenwei的博客-CSDN博客_动态sql 动态sql的第一个标签<sql>标签引用的时候要用<include>才可以 <sql id="allColumns"> id,username,birthday,sex,address </sql> <select id="getAll" resultType="org.example.pojo.Users">
动态sql
hhhahahaha的博客
06-30 133
1-if(存在where 连接 主外键) <!--通过userName和userRole，查询用户列表（包含用户角色名称）--> <!-- <select id="getUserListIncludeUserRoleName" parameterType="User" resultMap="zhoujielun"> SELECT u.*,r.`roleName` FROM smbms_user u,smbms_role r WHERE u
MyBatis【java进阶笔记六】
yuyu的博客
01-06 1693
JDBC；HiBernate；MyBatis
MyBatis sql（sql片段）标签使用（定义SQL、引用SQL）
旭东怪的博客
08-27 3369
sql标签可将重复的sql提取出来，使用时用include标签引用即可，最终达到sql重用的目的。 1 定义SQL <sql id="allColumn"> username,pickname,realname,password </sql> 2 引用SQL <select id="selectALL"> select <include refid="allColumn"></incl.
mybatis中sql标签的使用
热门推荐
朱玉强的博客
05-06 2万+
mybatis中sql标签重要是为了避免在项目开发的过程中重复编写大量相同的sql语句，例如下面的查询语句： <select id="selectCountryAndCity" parameterType="map" resultMap="countryAndCity1"> SELECT country.Code as country_code, country
【Mybatis】mybatis使用foreach批次插入，解决sequence只查询一次的问题（在此，我只看union all 部分）
keeper42的博客
02-18 1381
oracle的批量插入方式是： insert into db(id, zgbh, shbzh) select '1', '2', '3' from dual union all select '2', '3', '4' from dual union all select '3', '4', '5' from dual union all select '4', '5', '6' from dual union all sel...
MyBatis映射文件
猪哥
07-27 2114
guserdb2.userinfo on expert.useruid = userinfo.uid `showname` like CONCAT('%',#{showname_lk},'%') `company` like CONCAT('%',#{company_lk},'%') `job` like CONCAT('%',#{job_lk},'%') expert.`uid`, `
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值