MyBatis多参数处理(第二天)

zoukankan html css js c++ java

MyBatis多参数处理(第二天)

注：

Servlet：就是和前端页面打交道

        （接收请求+数据）

Service：调用mapper层进行增删改查

        Person （person   student teacher）

Mapper: 对pojo层进行增删改查操作

        （对某一个对象的增删改查就在哪个mapper中进行）

附：入参

返回值

（三） MyBatis多参数处理

MyBatis中方法中出现了多个参数的处理方式：

1、第一种使用方法索引

使用java方法的默认规范,参数是有索引，我们需要在sql中指定参数的的索引位置

<select>

select * from person where id=#{参数索引} and name=#{参数索引}

</select>

2、第二种map的key

使用map集合的方式传入多个参数值，在sql中我们使用map中的key来映射值

<select>

select * from person where id=#{map的key} and name=#{map的key}

</select>

3、第三种使用注解

使用MyBatis的注解 @Param("定义参数在sql中的应用名称")，在定义方法的时候声明sql中使用参数的名字

<select>

select * from person where id=#{ddi} and name=#{nnmae}

</select>

3、第四种使用自定义对象进行封装

<select>

select * from person where id=#{id} and name=#{name}

</select>

（四） 模糊查询

1、占位符方式

（1）构建PersonMapper接口

public interface PersonMapper {

public List<Person> findByName(String name);

}

（2）构建PersonMapper.xml

<mapper namespace="com.offcn.mapper.PersonMapper">

<select id="findByName" parameterType="string" resultType="person">

select * from person where name like #{name}

</select>

</mapper>

（3）测试

@Test

public void testFindByUsername() throws Exception {

PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);

List<Person> list = personMapper.findByName("%王%");

for (Person person: list) {

System.out.println(person);

}

}

2、字符串拼接方式

（1）构建PersonMapper接口

public interface PersonMapper{

public List<Person> findByName(String name);

}

（2）构建PersonMapper.xml

<mapper namespace="com.offcn.mapper.PersonMapper">



<select id="findByName" parameterType="string" resultType="person">

select * from person where name like "%"#{name}"%"

</select>

</mapper>

（3）测试

@Test

public void testFindByUsername() throws Exception {

PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);

List<Person> list = personMapper.findByName("王");

for (Person person: list) {

System.out.println(person);

}

}

3、$的拼接方式

(3)构建PersonMapper 接口

public interface PersonMapper {

public List<Person> findByName(String name);

}

构建PersonMapper.xml

<mapper namespace="com.offcn.mapper.PersonMapper ">



<select id="findByName" parameterType="string" resultType="person">

select * from person where name like '%${value}%'

</select>

</mapper>

测试

@Test

public void testFindByName() throws Exception {

PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);

List<Person> list = personMapper.findByName("王");

for (Person person: list) {

System.out.println(person);

}

}

4、使用函数拼接数据

（1）构建PersonMapper 接口

public interface PersonMapper {

public List<Person> findByName(String name);

}

（2）构建PersonMapper.xml

<mapper namespace="com.offcn.mapper.PersonMapper">



<select id="findByName" parameterType="string" resultType="person">

select * from person where name like concat(concat('%',#{name}),'%');

</select>

</mapper>

（3）测试

@Test

public void testFindByName() throws Exception {

PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);

List<Person> list = personMapper.findByName("王");

for (Person person: list) {

System.out.println(person);

}

}

总结：${} 与 #{} 区别

#{} :表示一个占位符号

通过 #{} 可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。#{} 可以接收简单类型值或pojo属性值。

如果parameterType传输单个简单类型值， #{} 括号中可以是value或其它名称。

${} :表示拼接sql串

通过 ${} 可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换，会出现sql注入问题。

${} 可以接收简单类型值或pojo属性值。如果parameterType传输单个简单类型值， ${} 括号中可以使任意名称。

配置文件深入学习

（一）主键处理

应用场景

我们很多时候有这种需求，向数据库插入一条记录后，希望能立即拿到这条记录在数据库中的自动生成的主键值。以便后续业务的使用。

1、第一种方式使用属性useGeneratedKeys



<insert id="insert" parameterType="person" useGeneratedKeys="true" keyProperty="id">

INSERT INTO `person` (name,bir,address) values(#{name},#{bir},#{address})

</insert>

2、第二种方式使用标签selectKey



<insert id="insert" parameterType="person" useGeneratedKeys="true" keyProperty="id"> <selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">

SELECT LAST_INSERT_ID();

    </selectKey>

INSERT INTO `person` (name,bir,address) values(#{name},#{bir},#{address})

</insert>

（二）sql片段

1、应用场景

映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

2、实现步骤

(1) 抽取的sql片段

<sql id="column_list">

   Id,name,bir,address

</sql>

(2) 使用sql片段

<select id="findById" parameterType="int" resultType="person" >



select <include refid="column_list"></include> from person where id=#{id}

</select>

注：在我们需要使用公共sql的地方，使用标签 include 引入sql片段。

（三）plugins分页查询

1、应用场景

MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据，分页功能只需要在配置文件中引入plugins标签。

2、代码实现

(1) 导入PageHelper分页插件坐标



<dependency>

<groupId>com.github.pagehelper</groupId>

<artifactId>pagehelper</artifactId>

  <version>5.1.3</version>

</dependency>

(2) 在MyBatis核心配置文件配置PageHelper分页插件



<plugins>

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

</plugins>

(3) 测试代码

// 分页插件测试

@Test

public void testPageHelper() throws Exception {

PersonMapper personMapper = sqlSession.getMapper(PersonMapper.class);

// 指定查询页码和每页显示条数

PageHelper.startPage(1, 3);

List<Person> list = PersonMapper.findByIdAndNameIf(null);

for (Person person: list) {

System.out.println(person);

}

// 获取其他分页数据

PageInfo<Person> pageInfo = new PageInfo<>(list);

System.out.println(pageInfo.getTotal()); //总记录数

System.out.println(pageInfo.getPages());//总页数

System.out.println(pageInfo.getPageNum()); //当前页

System.out.println(pageInfo.getPageSize());//每页显示条数

System.out.println(pageInfo.isIsFirstPage());//是否为第一页

System.out.println(pageInfo.isIsLastPage());//是否为最后一页

}

二、MyBatis的多表联合查询

（一）一对一

一对一操作：通过一方可以关联查询出另外一方的关系数据

案例中是通过Person可以查询当前Person关联的唯一的证件Card的数据,在card表中我们设定了一个外键字段per_fk 关联peson表中的主键id字段。

1、创建数据库表

  CREATE TABLE `person` (

  `id` int(11) NOT NULL AUTO_INCREMENT,

  `name` varchar(32) DEFAULT NULL,

   PRIMARY KEY (`id`)

)

CREATE TABLE `card` (

  `id` int(11) NOT NULL AUTO_INCREMENT,

  `name` varchar(32) DEFAULT NULL,

  `num` varchar(32) DEFAULT NULL,

  `per_fk` int(11) DEFAULT NULL,

   PRIMARY KEY (`id`)

)

2、创建类Person

public class Person implements Serializable {

private int id;

private String name;

private Card card ;

3、创建Person的关联类型 Card

public class Card implements Serializable {

    private int id;

    private String name;

private String num;

4、创建PersonMapper接口定义方法

public Person getInfoByName( @Param("name") String name);

5、创建文件 PersonMapper.xml

<resultMap type="person" id="newperson">

        <id property="id" column="id"/>

        <result property="name" column="name"/>

        

       <association property="card" column="id" javaType="com.offcn.bean.Card">

           <id property="id" column="id"/>

           <result property="name" column="name"/>

           <result property="num" column="num"/>

        </association>

  </resultMap>

<select id="getInfoById" parameterType="string" resultMap="newperson">

   

    SELECT p.*,c.* FROM person p,card c WHERE p.id=c.per_fk AND p.name=#{name}

  </select>

6、编写mybatis-config.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"><configuration>

  <environments default="development">

    <environment id="development">

      <transactionManager type="JDBC"/>

      <dataSource type="POOLED">

        <property name="driver" value="${driver}"/>

        <property name="url" value="${url}"/>

        <property name="username" value="${username}"/>

        <property name="password" value="${password}"/>

      </dataSource>

    </environment>

  </environments>

    <mappers>

<mapper resource="org/offcn/mapper/PersonMapper.xml"/>

</mappers>

</configuration>

7、编码测试

@Test

public void test() {

//使用MyBatis的内置工具类解析MyBatis-config.xml文件

String filename="MyBatis-config.xml";

try {

    //使用流读取文件

InputStream is = Resources.getResourceAsStream(filename);

//根据流读取的内容创建一个MyBatis的核心对象

SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);

//生成session

SqlSession session = build.openSession();

PersonMapper mapper = session.getMapper(PersonMapper.class);

Person infoByName= mapper.getInfoByName("小黑");

System.out.println(infoByName);

//提交事务

session.commit();

//关闭session

session.close();

} catch (Exception e) {

e.printStackTrace();

}

（二）一对多

本案例采用的是用户和订单来进行讲解，一个用户可以关联查询出自己的订单信息，在订单表中添加一个外键字段关联用户表中的主键。

1、创建对应的数据库表

订单表

   CREATE TABLE `orders` (

   `oid` varchar(64) NOT NULL,

   `odis` varchar(32) DEFAULT NULL,

   `onum` varchar(32) DEFAULT NULL,

   `cus_fk` int(11) DEFAULT NULL,

    PRIMARY KEY (`oid`),

);

用户表

CREATE TABLE `customer` (

`id` int(11) NOT NULL AUTO_INCREMENT,

`name` varchar(32) DEFAULT NULL,

PRIMARY KEY (`id`)

);

2、构建bean类Customer

public class Customer implements Serializable {

private int id;

private String name;

private List<Orders> orders;

3、创建bean类Orders

public class Orders implements Serializable {

    private int oid;

    private String odis;

private String onum;

4、创建CustomerMapper接口并定义方法

public Customer getInfoByName( @Param("name") String name);

5、创建CustomerMapper接口对应的映射文件 CustomerMapper.xml

<resultMap type="customer" id="newCustomer">

       <id property="id" column="id"/>

       <result property="name" column="name"/>



<collection property="orders" column="id" ofType="com.offcn.bean.Orders" >

<id property="oid" column="oid" />

<result property="odis" column="odis"/>

            <result property="onum" column="onum"/>

</collection>

</resultMap>

<select id="getInfoByName" parameterType="string" resultMap="newperson">

select c.*,o.* from customer c ,orders o where c.id=o.per_fk and c.name=#{name}

</select>

6、编写mybatis-config.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"><configuration>

  <environments default="development">

    <environment id="development">

      <transactionManager type="JDBC"/>

      <dataSource type="POOLED">

        <property name="driver" value="${driver}"/>

        <property name="url" value="${url}"/>

        <property name="username" value="${username}"/>

        <property name="password" value="${password}"/>

      </dataSource>

    </environment>

  </environments>

    <mappers>

<mapper resource="org/offcn/mapper/CustomerMapper.xml"/>

</mappers>

</configuration>

7、编码测试

@Test

  public void test() {

    //使用MyBatis的内置工具类解析MyBatis-config.xml文件

String filename="MyBatis-config.xml";

try {

//使用流读取文件

InputStream is = Resources.getResourceAsStream(filename);

//根据流读取的内容创建一个MyBatis的核心对象

SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);

//生成session

SqlSession session = build.openSession();

CustomerMapper mapper = session.getMapper(CustomerMapper .class);

Person info = mapper.getInfoByName("小黑");

List<Orders> cards = info.getOrders();

for(Orders ods:cards) {

System.out.println("订单信息为名称"+ods.getOnum()+ods.getOdis());

}

//提交事务

session.commit();

//关闭session

session.close();

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

（三）多对多

物品(items)和订单(orders)是多对多映射.两者实际上是通过OrderDetails中间表完成了关联.

需求:查询用户.同时查询出用户所关联的所有的订单,同时查询出订单所对应的所有的订单项以及订单项所对应的物品.

1、创建实体bean对应的表

用户表

CREATE TABLE `customer` (

  `cid` int(11) NOT NULL AUTO_INCREMENT,

  `name` varchar(32) DEFAULT NULL,

  PRIMARY KEY (`id`)

)

订单表

CREATE TABLE `orders` (

  `oid` int(11) NOT NULL AUTO_INCREMENT,

  `dis` varchar(32) DEFAULT NULL,

`cus_fk` int(11) DEFAULT NULL,

  PRIMARY KEY (`id`)

  FOREIGN KEY (`cus_fk`) REFERENCES `customer` (`id`)

)

商品表

CREATE TABLE `items ` (

  `itemid` int(11) NOT NULL AUTO_INCREMENT,

  `name` varchar(32) DEFAULT NULL,

  `price` double DEFAULT NULL,

  PRIMARY KEY (`id`)

)

订单详情表

CREATE TABLE `ordersdetail ` (

  `odid` int(11) NOT NULL AUTO_INCREMENT,

  `items_id` int(11) DEFAULT NULL,

`orders_id` int(11) DEFAULT NULL,

PRIMARY KEY (`id`)

FOREIGN KEY (`items_id`) REFERENCES `items` (`itemid`)

FOREIGN KEY (`orders_id`) REFERENCES `orders` (`oid`)

  )

2、创建bean模型类 Customer

public class Customer implements Serializable {

private int cid;

private String name;

private List<Orders> orders;

3、创建订单模型Orders

public class Orders implements Serializable {

    private int oid;

private String dis;

Private Customer customer;

Private List<Orderdetail> detailList

4、创建商品模型Items

public class Items implements Serializable {

    private int itemid;

    private String name;

private double price;

5、创建订单详情模型Ordersdetail

public class Ordersdetail implements Serializable {

    private int odid;

private Orders orders;

private Items items;

6、创建接口 CustomerMapper

List<Customer> findCustomerById(Integer cid);

7、创建Mapper接口对应的配置文件 UserMapper.xml

<resultMap type="Customer" id="userManyToManyMap">

        

        <id column="cid" property="cid"/>

        <result column="name" property="name"/>

        

        <collection property="orders" ofType="Orders">

            <id column="oid" property="oid"/>

            <result column="dis" property="dis"/>

            

            <collection property="detailList" ofType="Orderdetail">

                <id column="odid" property="odid"/>

                 

                <association property="items" javaType="Items">

                    <id column="itemid" property="itemid"/>

                    <result column="name" property="name"/>

                    <result column="price" property="price"/>

                </association>

            </collection>

        </collection>

    </resultMap>

    <select id="findAllUsers" parameterType="int" resultMap="userManyToManyMap">

        SELECT c.*,o.*,od.*,i.*

        FROM customer c,orders o,orderdetail od,items i

        WHERE c.cid=o.cus_fk and o.oid=od.orders_id

        AND od.items_id=i.itemid and c.cid=#{cid}

    </select>

8、测试代码

@Test

  public void test() {

    //使用MyBatis的内置工具类解析MyBatis-config.xml文件

String filename="MyBatis-config.xml";

try {

//使用流读取文件

InputStream is = Resources.getResourceAsStream(filename);

//根据流读取的内容创建一个MyBatis的核心对象

SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);

//生成session

SqlSession session = build.openSession();

CustomerMapper mapper = session.getMapper(CustomerMapper .class);

Person info = mapper.getInfoByName(1);

System.out.println(info);

         }catch(Exception e){

            e.printStackTrace();

}

}

三、MyBatis的嵌套查询

什么是嵌套查询

嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用MyBatis的语法嵌套在一起。

（一）一对一的嵌套

需求：查询一个订单，与此同时查询出该订单所属的用户

代码实现

1、OrdersMapper接口中定义方法

public interface OrderMapper {

public List<Order> findAllWithUser();

}

2、OrderMapper.xml映射



<resultMap id="orderMap" type="orders">

<id column="oid" property="oid"></id>

<result column="dis" property="dis"></result>



<association

property="customer"

javaType="com.offcn.bean.Customer"

column="cus_fk"

select="com.offcn.mapper.CustomerMapper.findById"

</association>

</resultMap>

<select id="findAllWithCustomer" resultMap="orderMap" >

SELECT * FROM orders

</select>

3、CustomerMapper接口

  Customer findById(Integer cid);

4、CustomerMapper.xml 映射

<select id="findById" parameterType="int" resultType="com.offcn.bean.Customer">

SELECT * FROM `customer` where cid = #{cid}

</select>

5、测试代码

@Test

public void testOrderWithCustomer() throws Exception {

OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);

List<Order> list = orderMapper.findAllWithCustomer();

for (Order order : list) {

System.out.println(order);

}

}

（二）一对多的嵌套

需求：查询一个用户，与此同时查询出该用户具有的订单

1、CustomerMapper接口并定义方法

public Customer getInfoByName( @Param("name") String name);

2、CustomerMapper.xml映射文件

<resultMap type="Customer" id="newCustomer">

       <id property="cid" column="cid"/>

       <result property="name" column="name"/>

        <collection

property="orders"

column="id"

ofType="com.offcn.bean.Orders"

select="com.offcn.mapper.OrdersMapper.getOneByfk">

        </collection>

</resultMap>

    <select id="getInfoByName" resultMap="newperson">

    SELECT c.*FROM customer c WHERE c.name=#{name};

    </select>

3、OrdersMapper接口

public Orders getOneByfk(int fk);

4、OrdersMapper.xml的映射文件

   <select id="getOneByfk" resultType="com.offcn.bean.Orders">

      select * from orders where cus_fk=#{cusid}

   </select>

5、测试代码

@Test

public void testOrderWithCustomer() throws Exception {

CustomerMapper customerMapper= sqlSession.getMapper(CustomerMapper.class);

Customer customer = customerMapper.getInfoByName(“张三”);

System.out.println(customer );

}

四、MyBatis的动态sql

（一）动态sql基本使用

1、动态sql之 <if>、<where>

需求

根据id和username查询，但是不确定两个都有值。

（1）PersonMapper接口

public List<Person> findByIdAndNameIf(Person person);

（2）PersonMapper.xml映射



<select id="findByIdAndNameIf" parameterType="person" resultType="person">

   SELECT * FROM `person`

<where>

<if test="id != null">

AND id = #{id}

</if>

<if test="name != null">

AND name= #{name}

</if>

</where>

</select>

（3）测试代码

// if标签 where标签

@Test

public void testFindByIdAndUsernameIf() throws Exception {

PersonMapper personMapper = sqlSession.getMapper(PersonMapper .class);

Person param = new Person();

// param.setId(2);

// param.setName("张三");

List<User> list = personMapper .findByIdAndNameIf(param);

System.out.println(list);

}

2、动态sql之<choose>

需求

如果有id只使用id做查询，没有id的话看是否有name，有name就根据name做查询，如果都没有，就不带条件查询全部内容。

（1）PersonMapper接口

public List<Person> findByIdAndNameChoose(Person person);

（2）PersonMapper.xml文件



<select id="findByIdAndNameChoose" parameterType="person" resultType="person"> SELECT * FROM `person`

<where>

<choose>

<when test="id != null">

AND id = #{id}

</when>

<when test="name!= null">

AND name= #{name}

</when>

<otherwise>

AND 1=1

</otherwise>

</choose>

</where>

</select>

（3）测试代码

@Test

public void findByIdAndNameChoose() throws Exception {

PersonMapper personMapper = sqlSession.getMapper(PersonMapper .class);

Person param = new Person();

// param.setId(2);

// param.setName("张三");

List<User> list = personMapper .findByIdAndNameChoose(param);

System.out.println(list);

}

3、动态sql之<set>

需求

动态更新user表数据，如果该属性有值就更新，没有值不做处理。

（1）PersonMapper接口

public void updateIf(Person person);

（2）PersonMapper.xml文件



<update id="updateIf" parameterType="person">

UPDATE `person`

<set>

<if test="name!= null"> name= #{name}, </if>

<if test="bir!= null"> bir= #{bir}, </if>

<if test="address !=null"> address = #{address}, </if>

</set>

WHERE id = #{id}

</update>

（3）测试代码

@Test

public void testUpdateIf()throws Exception{

PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);

Person person = new Person();

person .setId(1);

person .setName("李四");

personMapper.updateIf(person);

}

4、动态sql之<trim>(了解)

（1）重写set标签

<update id="updateIf" parameterType="person">

UPDATE `person`

<trim prefix="set" suffixOverrides=",">

<if test="name!= null"> name= #{name}, </if>

<if test="bir!= null"> bir= #{bir}, </if>

<if test="address !=null"> address = #{address}, </if>

</trim>

WHERE id = #{id}

</update>

（2）重写where标签



<select id="findByIdAndNameIf" parameterType="person" resultType="person">

select * from person

<trim prefix="where" prefixOverrides="and | or">

<if test="id != null "> and id = #{id} </if>

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

</trim>

</select>

（3）测试代码使用对应标签的测试代码就好，不需要更改，这里就省略了。

（二）动态sql的高级应用

1、动态sql之<foreach>

foreach主要是用来做数据的循环遍历

例如： select * from person where id in (1,2,3) 在这样的语句中,传入的参数部分必须依靠 foreach遍历才能实现。

标签简介

<foreach>标签用于遍历集合，它的属性：

collection：代表要遍历的集合元素

open：代表语句的开始部分

close：代表结束部分

item：代表遍历集合的每个元素，生成的变量名

sperator：代表分隔符

（1）集合类型参数

a.创建PersonMapper接口

public List<Person> findByList(List<Integer> ids);

b.PersonMapper.xml映射文件



<select id="findByList" parameterType="list" resultType="person" >

SELECT * FROM `person`

<where>

<foreach collection="collection" open="id in(" close=")"  item="id"  separator=",">

#{id}

</foreach>

</where>

</select>

c.测试代码

// foreach标签 list

@Test

public void testFindByList() throws Exception {

PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);

List<Integer> ids = new ArrayList<>();

ids.add(46);

ids.add(48);

ids.add(51);

List<User> list = personMapper.findByList(ids);

System.out.println(list);

}

(2)数组

a.PersonMapper接口

public List<Person> findByArray(Integer[] ids);

b.PersonMapper.xml映射文件



<select id="findByArray" parameterType="int[]" resultType="person">

SELECT * FROM `person`

<where>

<foreach collection="array" open="id in(" close=")" item="id" separator=","> #{id} </foreach> </where>

</select>

c.测试代码

@Test

public void testFindByArray() throws Exception {

PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);

Integer[] ids = {12, 23, 34};

List<User> list = userMapper.findByArray(ids);

System.out.println(list);

}

查看全文

相关阅读:
koa2 中间件里面的next到底是什么
 nodejs 之 nvm和pm2
javascript瀑布流
 转使用chrome命令行：disable
MariaDB 用户与授权
 MariaDB TRANSACTION
IHS .kdb转crt,key
MariaDB TRIGGER
MariaDB CURSOR
MariaDB PROCEDURE

原文地址：https://www.cnblogs.com/masterhxh/p/13810572.html

MyBatis多参数处理(第二天)

附：入参

返回值

（三） MyBatis多参数处理

（四）模糊查询

配置文件深入学习

（一）主键处理

（二）sql片段

（三）plugins分页查询

二、MyBatis的多表联合查询

（一）一对一

（二）一对多

（三）多对多

三、MyBatis的嵌套查询

（一）一对一的嵌套

（二）一对多的嵌套

四、MyBatis的动态sql

（一）动态sql基本使用

（二）动态sql的高级应用

MyBatis多参数处理(第二天)

附： 入参

返回值

（三） MyBatis多参数处理

（四） 模糊查询

配置文件深入学习

（一）主键处理

（二）sql片段

（三）plugins分页查询

二、MyBatis的多表联合查询

（一） 一对一

（二） 一对多

（三）多对多

三、MyBatis的嵌套查询

（一）一对一的嵌套

（二）一对多的嵌套

四、MyBatis的动态sql

（一） 动态sql基本使用

（二）动态sql的高级应用

附：入参

（四）模糊查询

（一）一对一

（二）一对多

（一）动态sql基本使用