myBatis之动态sql以及分页

最新推荐文章于 2022-08-12 11:59:37 发布

Lee_mons

最新推荐文章于 2022-08-12 11:59:37 发布

阅读量1.1k

点赞数

分类专栏： mybatis 文章标签： sql 数据库 database

本文链接：https://blog.youkuaiyun.com/Cat_Jay_Fish/article/details/121918946

版权

mybatis 专栏收录该内容

6 篇文章

订阅专栏

本文详细介绍了myBatis中动态SQL的使用，包括if、foreach标签的应用，以及模糊查询的实现方式，对比了#与$的区别。同时，探讨了查询结果集的处理，包括resultMap和resultType的适用场景。此外，还讲解了myBatis的分页查询，如何通过PageHelper插件实现高效分页，并展示了特殊字符处理的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

目标

1.mybatis动态sql

2.模糊查询

3.查询返回结果集的处理

4.分页查询

5.特殊字符处理

一、mybatis动态sql

常用：If、foreach

if标签解释：

foreach：

1、BookMapper.xml增加foreach标签

<select id="selectBooksIn" resultType="com.mwy.model.Book" parameterType="java.util.List">
select * from t_mvc_book where bid in
<foreach collection="bookIds" open="(" close=")" separator="," item="bid">
#{bid}
</foreach>
</select>

2、dao层调用

BookMapper.java

有且只有一个变量，指名

List<Book> selectBooksIn(@Param("bookIds") List bookIds);

3、做测试
①、BookService.java

List<Book> selectBooksIn(List bookIds);

②、实现接口方法（BookServiceImpl.java）

public List<Book> selectBooksIn(List bookIds) {
return bookMapper.selectBooksIn(bookIds);
}

③、测试类测试（BookServiceImplTest.java）

二、模糊查询

（是一道面试题）

#{...} 、 ${...} 、 Concat 三个都可以实现模糊查询

注意：#{...}自带引号，${...}不带引号，有sql注入的风险

在不考虑做通用的业务功能增删改查的时候选用Concat；

做通用的业务功能增删改查的时候选用${...}；

除了做模糊查询不用#{...}，其他都用#{...}；

#与$符号的区别：

1、BookMapper.xml增加三种写法

#{...}：%号需要在后台拼接；

<select id="selectBooksLike1" resultType="com.lsy.model.Book" parameterType="java.lang.String">
  select * from t_mvc_book where bname like #{bname}
</select>
<select id="selectBooksLike2" resultType="com.lsy.model.Book" parameterType="java.lang.String">
  select * from t_mvc_book where bname like '${bname}'
</select>
<select id="selectBooksLike3" resultType="com.lsy.model.Book" parameterType="java.lang.String">
  select * from t_mvc_book where bname like concat(concat('%',#{bname}),'%')
</select>

2、dao层调用

BookMapper.java

List<Book> selectBooksLike1(@Param("bname") String bname);
List<Book> selectBooksLike2(@Param("bname") String bname);
List<Book> selectBooksLike3(@Param("bname") String bname);

3、做测试

①、BookService.java

@Override
public List<Book> selectBooksLike1(String bname) {
return bookMapper.selectBooksLike1(bname);
}

@Override
public List<Book> selectBooksLike2(String bname) {
return bookMapper.selectBooksLike2(bname);
}

@Override
public List<Book> selectBooksLike3(String bname) {
return bookMapper.selectBooksLike3(bname);
}

③、测试类测试（BookServiceImplTest.java）

@Test
public void testSelectBooksLike1() {
    System.out.println("mybatis中模糊查询#与$的区别.....");
    List<Book> books=this.bookService.selectBooksLike1("%圣墟%");
    books.forEach(System.out::println);
}

@Test
public void testSelectBooksLike2() {
    System.out.println("mybatis中模糊查询#与$的区别.....");
    List<Book> books=this.bookService.selectBooksLike2("%圣墟%");
    books.forEach(System.out::println);
}

@Test
public void testSelectBooksLike3() {
    System.out.println("mybatis中模糊查询#与$的区别.....");
    List<Book> books=this.bookService.selectBooksLike3("圣墟");
    books.forEach(System.out::println);
}

结果：模糊查询都能使用

#: $: Concat: 三个测试结果都一样

总结：#和$的区别？

#{...}自带引号，

${...}不带引号，有sql注入的风险，但是${...}能做mybatis动态功能页的功能，

有的时候会模块与模块之间调用会在别人的代码上做修改，所以开发动态页的功能，他可以减少dao层与mapper.xml的代码编辑

三、查询返回结果集的处理

resultMap对应1的情况；

resultType对应2、3、4、5四种情况；

resultMap：适合使用返回值是自定义实体类的情况

resultType：适合使用返回值的数据类型是非自定义的，即jdk的提供的类型

1 使用resultMap返回自定义类型集合

2 使用resultType返回List<T>

3 使用resultType返回单个对象

4 使用resultType返回List<Map>，适用于多表查询返回结果集

5 使用resultType返回Map<String,Object>，适用于多表查询返回单个结果集

1、BookMapper.xml增加返回结果集的处理

 <select id="list1" resultMap="BaseResultMap">
    select * from t_mvc_book
  </select>
  <select id="list2" resultType="com.lsy.model.Book">
    select * from t_mvc_book
  </select>
  <select id="list3" resultType="com.lsy.model.Book" parameterType="com.lsy.vo.BookVo">
    select * from t_mvc_book where bid in
    <foreach collection="bookIds" open="(" close=")" separator="," item="bid">
      #{bid}
    </foreach>
  </select>
  <select id="list4" resultType="java.util.Map">
    select * from t_mvc_book
  </select>
  <select id="list5" resultType="java.util.Map" parameterType="java.util.Map">
    select * from t_mvc_book where bid = #{bid}
  </select>

新建BookVo.java

package com.lsy.vo;

import com.lsy.model.Book;

import java.util.List;

public class BookVo extends Book {
    private List<Integer> bookIds;

    public List<Integer> getBookIds() {
        return bookIds;
    }

    public void setBookIds(List<Integer> bookIds) {
        this.bookIds = bookIds;
    }



}

2、dao层调用

BookMapper.java

/**
     * 使用resultMap返回自定义类型集合
     * @return
     */
    List<Book> list1();

    /**
     * 使用resultType返回List<T>
     * @return
     */
    List<Book> list2();

    /**
     * 使用resultType返回单个对象
     * @return
     */
    Book list3(BookVo bookVo);

    /**
     * 使用resultType返回List<Map>，适用于多表查询返回结果集
     * @return
     */
    List<Map> list4();

    /**
     * 使用resultType返回Map<String,Object>，适用于多表查询返回单个结果集
     * @return
     */
    Map list5(Map book);

3、做测试

①、BookService.java

/**
     * 使用resultMap返回自定义类型集合
     * @return
     */
    List<Book> list1();

    /**
     * 使用resultType返回List<T>
     * @return
     */
    List<Book> list2();

    /**
     * 使用resultType返回单个对象
     * @return
     */
    Book list3(BookVo bookVo);

    /**
     * 使用resultType返回List<Map>，适用于多表查询返回结果集
     * @return
     */
    List<Map> list4();

    /**
     * 使用resultType返回Map<String,Object>，适用于多表查询返回单个结果集
     * @return
     */
    Map list5(Map book);

②、实现接口方法（BookServiceImpl.java）

@Override
    public List<Book> list1() {
        return bookMapper.list1();
    }

    @Override
    public List<Book> list2() {
        return bookMapper.list2();
    }

    @Override
    public Book list3(BookVo bookVo) {
        return bookMapper.list3(bookVo);
    }

    @Override
    public List<Map> list4() {
        return bookMapper.list4();
    }

    @Override
    public Map list5(Map book) {
        return bookMapper.list5(book);
    }

③、测试类测试（BookServiceImplTest.java）

/**
     * 结论1：
     * resultMap:多表查询会用
     * resultType：单表查询
     *
     * 结论2：
     * List<T></>:单表
     * List<Map></>:多表
     *
     */
    @Test
    public void testList1() {
        System.out.println("五种返回类型配置");
        List<Book> books=this.bookService.list1();
        books.forEach(System.out::println);
    }

    @Test
    public void testList2() {
        System.out.println("五种返回listbook对象");
        List<Book> books=this.bookService.list2();
        books.forEach(System.out::println);
    }

    @Test
    public void testList3() {
        System.out.println("五种返回类型配置之返回单个对象");
        BookVo bookVo=new BookVo();
        bookVo.setBookIds(Arrays.asList(new Integer[]{29}));
        this.bookService.list3(bookVo);
    }

    @Test
    public void testList4() {
        System.out.println("五种返回类型配置之返回listMap对象");
        List<Map> books=this.bookService.list4();
        books.forEach(System.out::println);
    }

    @Test
    public void testList5() {
        System.out.println("五种返回类型配置之返回Map集合");
        Map map=new HashMap();
        map.put("bid",29);
        Map m=this.bookService.list5(map);
        System.out.println(m);
    }

结果：

（1）使用resultMap返回自定义类型集合：

（2）使用resultType返回List<T>

（3）使用resultType返回单个对象

（4）使用resultType返回List<Map>，适用于多表查询返回结果集

（5）使用resultType返回Map<String,Object>，适用于多表查询返回单个结果集

四、分页查询

为什么要重写mybatis的分页？

Mybatis的分页功能很弱，它是基于内存的分页(查出所有记录再按偏移量offset和边界limit取结果)，在大数据量的情况下这样的分页基本上是没有用的

1、导入pom依赖

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.2</version>
</dependency>

2、Mybatis.cfg.xml配置拦截器（放在mybatis运行环境前面）

<plugins>

<plugin interceptor="com.github.pagehelper.PageInterceptor">
</plugin>
</plugins>

3、BookMapper.xml增加分页

<select id="listPager" resultType="java.util.Map" parameterType="java.util.Map">
select * from t_mvc_book where bname like concat(concat('%',#{bname}),'%')
</select>

4、dao层调用

BookMapper.java

List<Map> listPager(Map map);

5、做测试

导入PageBean.java

package com.lsy.util;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

/**
 * 分页工具�?
 *
 */
public class PageBean {

	private int page = 1;// 页码

	private int rows = 10;// 页大�?

	private int total = 0;// 总记录数

	private boolean pagination = true;// 是否分页
	
	private String url; //保存上一次请求的URL
	
	private Map<String,String[]> paramMap = new HashMap<>();// 保存上一次请求的参数
	
	/**
	 * 初始化pagebean的，保存上一次请求的重要参数
	 * @param req
	 */
	public void setRequest(HttpServletRequest req) {
//		1.1	�?要保存上�?次请求的URL
		this.setUrl(req.getRequestURL().toString());
//		1.2	�?要保存上�?次请求的参数	bname、price
		this.setParamMap(req.getParameterMap());
//		1.3	�?要保存上�?次请求的分页设置	pagination
		this.setPagination(req.getParameter("pagination"));
//		1.4	�?要保存上�?次请求的展示条目�?
		this.setRows(req.getParameter("rows"));
//		1.5  初始化请求的页码	page
		this.setPage(req.getParameter("page"));
	}
	
	public void setPage(String page) {
		if(StringUtils.isNotBlank(page))
			this.setPage(Integer.valueOf(page));
	}

	public void setRows(String rows) {
		if(StringUtils.isNotBlank(rows))
			this.setRows(Integer.valueOf(rows));
	}

	public void setPagination(String pagination) {
//		只有在前台jsp填写了pagination=false，才代表不分�?
		if(StringUtils.isNotBlank(pagination))
			this.setPagination(!"false".equals(pagination));
	}


	public String getUrl() {
		return url;
	}

	public void setUrl(String url) {
		this.url = url;
	}

	public Map<String, String[]> getParamMap() {
		return paramMap;
	}

	public void setParamMap(Map<String, String[]> paramMap) {
		this.paramMap = paramMap;
	}



	public PageBean() {
		super();
	}

	public int getPage() {
		return page;
	}

	public void setPage(int page) {
		this.page = page;
	}

	public int getRows() {
		return rows;
	}

	public void setRows(int rows) {
		this.rows = rows;
	}

	public int getTotal() {
		return total;
	}

	public void setTotal(int total) {
		this.total = total;
	}

	public void setTotal(String total) {
		this.total = Integer.parseInt(total);
	}

	public boolean isPagination() {
		return pagination;
	}

	public void setPagination(boolean pagination) {
		this.pagination = pagination;
	}

	/**
	 * 获得起始记录的下�?
	 * 
	 * @return
	 */
	public int getStartIndex() {
		return (this.page - 1) * this.rows;
	}
	
	/**
	 * �?大页
	 * @return
	 */
	public int maxPage() {
//		total % rows == 0 ? total / rows : total / rows +1
		return this.total % this.rows == 0 ? this.total / this.rows : this.total / this.rows + 1;
	}
	
	/**
	 * 下一�?
	 * @return
	 */
	public int nextPage() {
//		如果当前页小于最大页，那就下�?页为当前�?+1；如果不小于，说明当前页就是�?大页，那就无�?+1
		return this.page < this.maxPage() ? this.page + 1 : this.page;
	}
	
	/**
	 * 上一�?
	 * @return
	 */
	public int previousPage() {
		return this.page > 1 ? this.page - 1 : this.page;
	}

	@Override
	public String toString() {
		return "PageBean [page=" + page + ", rows=" + rows + ", total=" + total + ", pagination=" + pagination + "]";
	}

}

StringUtils .java

package com.lsy.util;

public class StringUtils {
	// 私有的构造方法，保护此类不能在外部实例化
	private StringUtils() {
	}

	/**
	 * 如果字符串等于null或去空格后等�?""，则返回true，否则返回false
	 * 
	 * @param s
	 * @return
	 */
	public static boolean isBlank(String s) {
		boolean b = false;
		if (null == s || s.trim().equals("")) {
			b = true;
		}
		return b;
	}
	
	/**
	 * 如果字符串不等于null或去空格后不等于""，则返回true，否则返回false
	 * 
	 * @param s
	 * @return
	 */
	public static boolean isNotBlank(String s) {
		return !isBlank(s);
	}

}

①、BookService.java

List<Map> listPager(Map map, PageBean pageBean);

②、实现接口方法（BookServiceImpl.java）

@Override
public List<Map> listPager(Map map, PageBean pageBean) {
    if (pageBean != null && pageBean.isPagination()) {
        PageHelper.startPage(pageBean.getPage(), pageBean.getRows());
    }
    List<Map> list = bookMapper.listPager(map);
    if (pageBean != null && pageBean.isPagination()) {
        PageInfo pageInfo = new PageInfo(list);
        System.out.println("页码：" + pageInfo.getPageNum());
        System.out.println("页大小：" + pageInfo.getPageSize());
        System.out.println("总记录：" + pageInfo.getTotal());
        pageBean.setTotal(pageInfo.getTotal() + "");
    }
    return list;
}

③、测试类测试（BookServiceImplTest.java）

@Test
public void testListPager() {
    System.out.println("mybatis中模糊查询#与$的区别.....");
    Map map=new HashMap();
    map.put("bname","圣墟");
    PageBean pageBean=new PageBean();
    pageBean.setPage(4);
    List<Map> ms=this.bookService.listPager(map,pageBean);
    ms.forEach(System.out::println);
}

结果展示

五、特殊字符处理

1、BookMapper.xml增加特殊字符处理

<select id="list6" resultType="com.lsy.model.Book" parameterType="com.lsy.vo.BookVo">
    select * from t_mvc_book
    <where>
      <if test="null != min and min != ''">
        <![CDATA[  and #{min} < price ]]>
      </if>
      <if test="null != max and max != ''">
        <![CDATA[ and #{max} > price ]]>
      </if>
    </where>
  </select>

  <select id="list7" resultType="com.lsy.model.Book" parameterType="com.lsy.vo.BookVo">
    select * from t_mvc_book
    <where>
      <if test="null != min and min != ''">
        and #{min} &lt; price
      </if>
      <if test="null != max and max != ''">
        and #{max} &gt; price
      </if>
    </where>
  </select>

2、dao层调用

BookMapper.java

/**
* 处理特殊字符
* @param bookVo
* @return
*/
List<Book> list6(BookVo bookVo);

/**
* 处理特殊字符
* @param bookVo
* @return
*/
List<Book> list7(BookVo bookVo);

3、做测试

BookVo中增加

private float min;
    private float max;

    public float getMax() {
        return max;
    }

    public void setMax(float max) {
        this.max = max;
    }

    public float getMin() {
        return min;
    }

    public void setMin(float min) {
        this.min = min;
    }

①、BookService.java

 /**
     * 处理特殊字符
     * @param bookVo
     * @return
     */
    List<Book> list6(BookVo bookVo);


    /**
     * 处理特殊字符
     * @param bookVo
     * @return
     */
    List<Book> list7(BookVo bookVo);

②、实现接口方法（BookServiceImpl.java）

@Override
public List<Book> list6(BookVo bookVo) {
    return bookMapper.list6(bookVo);
}

@Override
public List<Book> list7(BookVo bookVo) {
    return bookMapper.list7(bookVo);
}

③、测试类测试（BookServiceImplTest.java）

 @Test
    public void testList6() {
        System.out.println("五种返回类型配置");
        BookVo vo=new BookVo();
        vo.setMin(20f);
        vo.setMax(40f);
        List<Book> books=this.bookService.list6(vo);
        books.forEach(System.out::println);
    }

    @Test
    public void testList7() {
        System.out.println("五种返回类型配置");
        BookVo vo=new BookVo();
        vo.setMin(20f);
        vo.setMax(40f);
        List<Book> books=this.bookService.list7(vo);
        books.forEach(System.out::println);
    }

结果：二个方法结果一样的

bye~