MybatisPlus

 官网：MyBatis-Plus

起步依赖

<dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

配置

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #输出sql语句
    map-underscore-to-camel-case: true #开启驼峰映射
  mapper-locations: classpath*:/mappers/*.xml  #加载mapperxml文件
  type-aliases-package: com.qf.entity #别名扫描

实体映射

package com.example.entity;

import com.baomidou.mybatisplus.annotation.*;
import java.io.Serializable;
import lombok.Data;
@Data
@TableName("tb_goods")
public class TbGoods implements Serializable {
        /**
        * 标记该属性对应的字段是一个主键
        */
        @TableId(type = IdType.AUTO)
        private Integer goodsId;
        /**
        * 当属性名和字段名不一致，必须通过@TableField映射
        */
        @TableField("goods_stock")
        private Integer goodsStock1;
        /**
        * 
        */
        private Double goodsPrice;
        /**
        * 
        */
        private String goodsName;
}

package com.example.entity;

import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.io.Serializable;
@Data
@TableName("tb_order")
public class TbOrder implements Serializable {
    /**
     *
     */
    @TableId(type = IdType.AUTO)
    private String orderId;
    /**
     *
     */
    private Integer orderNum;
    /**
     *
     */
    private Double orderAmount;
    /**
     *
     */
    private Integer goodsId;
}

添加

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class TestGoodsMapper {
​
    @Autowired
    private GoodsMapper goodsMapper;
​
​
    @Test
    public void testSave(){
​
        TbGoods tbGoods = new TbGoods();
        tbGoods.setGoodsName("华为");
        tbGoods.setGoodsPrice(100.0);
        tbGoods.setGoodsStock1(10);
        goodsMapper.insert(tbGoods);
​
​
    }
​
}
​
注意：
//标记id为主键，同时这个主键是自增长的
@TableId(type = IdType.AUTO)

2.2：根据id删除

    @Test
    public void test1(){
        int i = goodsMapper.deleteById(2);
    }

2.3：根据 columnMap 条件，删除记录

columnMap 中的key必须是字段名不能是entity的属性名

@Test
    public void test2(){
​
        //删除条件
        Map where = new HashMap(){{
            put("goods_stock",100);
            put("goods_name","小米");
        }};
​
​
        int i = goodsMapper.deleteByMap(where);
    }

​

2.4：根据 entity 条件，删除记录

 @Test
    public void test3(){
​
​
        TbGoods tbGoods = new TbGoods();
        tbGoods.setGoodsId(12);
        tbGoods.setGoodsName("小米");
​
        UpdateWrapper updateWrapper = new UpdateWrapper(tbGoods);
​
        int i = goodsMapper.delete(updateWrapper);
    }

2.5：范围删除

   @Test
    public void test4(){
​
        //范围删除
        UpdateWrapper<TbGoods> updateWrapper = new UpdateWrapper<>();
​
        updateWrapper.gt("goods_stock",100).likeRight("goods_name","小米");
​
        goodsMapper.delete(updateWrapper);
    }

2.6：根据id批量删

  @Test
    public void testdelete1 (){
​
        List ids = new ArrayList(){{
            add(23);
            add(24);
            add(25);
        }};
​
​
        int i = iMemberMapper.deleteBatchIds(ids);
        System.out.println(i);
​
    }

2.7：根据id update

 @Test
    public void test5(){
​
​
        TbGoods goods = new TbGoods();
        goods.setGoodsId(3);
        goods.setGoodsName("小米");
​
        int i = goodsMapper.updateById(goods);
​
    }

2.8：UpdateWrapper

   @Test
    public void test6(){
​
        UpdateWrapper<TbGoods> updateWrapper = new UpdateWrapper<>();
​
        updateWrapper.eq("goods_id",3)
                .set("goods_name","苹果")
                .set("goods_stock",1000);
​
​
​
​
        int i = goodsMapper.update(null,updateWrapper);
    }

2.9：根据 ID 查询

 @Test
    public void testselect1 (){
​
​
        WxbMemeber memeber = iMemberMapper.selectById(21);
        System.out.println(memeber);
​
​
    }
​
@TableField(exist = false)//表示该属性不为数据库表字段，但又是必须使用的。
private List<Orders> orders;

2.10：查询（根据ID 批量查询）

​
    @Test
    public void testSelectByIds (){
​
        List ids = new ArrayList(){{
            add(24);
            add(28);
        }};
​
        List<User> list = userMapper.selectBatchIds(ids);
​
        for (User user : list) {
​
            System.out.println(user);
​
        }
​
    }

2.11：查询（根据 columnMap 条件）

columnMap的key必须为字段名

  @Test
        public void selectMap (){
​
            Map map =new HashMap(){{
                put("sex","1");
                put("id","22");
            }};
            List<User> list = userMapper.selectByMap(map);
            for (User user : list) {
                System.out.println(user);
            }
​
​
        }

2.12：根据 entity 条件

 @Test
    public void testQuerWraper (){
​
        User user = new User();
        user.setSex("1");
​
​
        //条案构造器
        Wrapper<User> userWrapper = new QueryWrapper<>(user);
​
​
​
        List<User> users = iUserMapper.selectList(userWrapper);
        for (User user1 : users) {
            System.out.println(user1);
        }
​
    }
​

2.13：QueryWrapper范围查询

  @Test
    public void test7(){
​
        QueryWrapper<TbGoods> queryWrapper = new QueryWrapper<>();
​
        queryWrapper.eq("goods_id",1)
                    .or()
                    .like("goods_name","小米");
​
​
        List<TbGoods> tbGoods = goodsMapper.selectList(queryWrapper);
​
        tbGoods.forEach(System.out::println);
    }

2.14：条件+分页查询（单表）

首先：配置拦截器，该拦截器可以拦截selectPage方法，并实现物理分页

package com.qfedu.config;
​
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
​
//Spring boot方式
@Configuration
public class MybatisPlusConfig {
​
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        // paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        // paginationInterceptor.setLimit(500);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }
}

其次：调用selectPage方法

  @Test
    public void test8(){
​
​
        //设置分页
        IPage page = new Page(1,2);
​
​
        //条件
        QueryWrapper<TbGoods> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("goods_name","小米");
​
​
        IPage pageinfo = goodsMapper.selectPage(page, queryWrapper);
​
​
        //获取分页信息
        pageinfo.getRecords().forEach(System.out::println);   //获取当前页数据
        long pages = pageinfo.getPages();  //总页数
​
​
    }

三：复杂查询

需求：分页查询订单包含订单对应的商品信息

mapper接口

package com.qf.mapper;
​
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.qf.entity.TbGoods;
import com.qf.entity.TbOrder;
import org.apache.ibatis.annotations.Param;
​
import java.util.List;
​
public interface GoodsMapper extends BaseMapper<TbGoods> {
​
​
    public IPage<TbOrder> findOrderAndGoodsInfoByPage(@Param("page") IPage page, @Param("tbOrder") TbOrder tbOrder);
​
​
}
​

mapper 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="com.qf.mapper.GoodsMapper">
​
<!-- public List<TbOrder> findOrderAndGoodsInfoByPage(@Param("page") IPage page, @Param("tbOrder") TbOrder tbOrder);-->
​
​
    <resultMap id="findOrderAndGoodsInfoByPageMap" type="TbOrder">
        <id column="order_id" property="orderId"></id>
        <result column="order_num" property="orderNum"></result>
        <association property="tbGoods" javaType="tbGoods">
            <id property="goodsId" column="goods_id"></id>
            <result column="goods_name" property="goodsName"></result>
        </association>
    </resultMap>
​
​
​
​
    <select id="findOrderAndGoodsInfoByPage" resultMap="findOrderAndGoodsInfoByPageMap">
        SELECT * FROM tb_order
                          LEFT JOIN tb_goods ON tb_order.goods_id = tb_goods.goods_id
        <where>
            <if test="tbOrder.orderNum!=null and tbOrder.orderNum!=''">
                and  tb_order.order_num = #{tbOrder.orderNum}
            </if>
        </where>
    </select>
</mapper>

单元测试

  @Test
    public void test9(){
​
        //设置分页
        IPage page = new Page(1,1);
​
​
        //条件
        TbOrder tbOrder = new TbOrder();
        tbOrder.setOrderNum(20);
​
        //分页查询
        IPage<TbOrder> pageInfo = goodsMapper.findOrderAndGoodsInfoByPage(page, tbOrder);
​
        //获取当前页数据
        pageInfo.getRecords().forEach(System.out::println);
​
        //获取总页数
        System.out.println(pageInfo.getPages());
    }