# springboot-mybatisplus

**Repository Path**: ck_567/springboot-mybatisplus

## Basic Information

- **Project Name**: springboot-mybatisplus
- **Description**: No description available
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-09-25
- **Last Updated**: 2021-06-23

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# mybatis-plus

### 一、MyBatis-Plus简介

MyBatis-Plus（简称 MP）是一个MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。 官网文档地址： https://mybatis.plus/guide/

### 二、SpringBoot集成MybatisPlus

- 第一步：通过maven坐标将mybatis-plus-boot-starter以及数据库驱动引入到Spring
  Boot项目里面来。注意：引入mybatis-plus-boot-starter的项目就不需要引入mybatis-spring-boot-starter了
  <dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
  <version>3.3.2</version>
  </dependency>
  <dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  </dependency>
- 第二步：保证application.yml里面有数据库连接的配置。 spring:
  datasource:
  url: jdbc:mysql://192.168.161.3:3306/testdb?useUnicode=true&characterEncoding=utf-8&useSSL=false username: test
  password: 4rfv$RFV driver-class-name: com.mysql.cj.jdbc.Driver
- 第三步：配置Mybatis的Mapper类文件的包扫描路径

````java

@SpringBootApplication
@MapperScan(basePackages = {"com.ck567.boot.launch.generator", "com.ck567.boot.launch.mapper"})
public class BootLaunchApplication {

    public static void main(String[] args) {
        SpringApplication.run(BootLaunchApplication.class, args);
    }

}
````

### 三、Mapper继承实现

如果我们操作数据库中的article表，我们需要按照article表的结构创建一个实体类。

````java

@Data
public class Article {
    private Long id;

    private String author;

    private String content;

    private String title;

    private Date createtime;
}
````

然后写一个接口ArticleMapper ，继承自BaseMapper，泛型是Article实体类。

````java
public interface ArticleMapper extends BaseMapper<Article> {

}
````

BaseMapper中默认帮我们提供了若干的增删改查基础实现，由于ArticleMapper 继承自BaseMapper ，所以ArticleMapper 可以使用这些方法去操作数据库的article表。

### 四、增删改查实现代码

````java

@Service
public class ArtivleServiceImpl implements ArticleService {
    @Resource
    protected Mapper dozerMapper;

    @Resource
    private ArticleMapper articleMapper;


    //新增
    @Override
    public void saveArticle(ArticleVO article) {
        Article articlePO = dozerMapper.map(article, Article.class);
        articleMapper.insert(articlePO);
    }

    //删除
    @Override
    public void deleteArticle(Long id) {
        articleMapper.deleteById(id);
    }

    //更新
    @Override
    public void updateArticle(ArticleVO article) {
        Article articlePO = dozerMapper.map(article, Article.class);
        articleMapper.updateById(articlePO);
    }

    //查询
    @Override
    public ArticleVO getArticle(Long id) {
        return dozerMapper.map(articleMapper.selectById(id), ArticleVO.class);
    }

    //查询所有
    @Override
    public List<ArticleVO> getAll() {
        List<Article> articles = articleMapper.selectList(null);
        return DozerUtils.mapList(articles, ArticleVO.class);
    }
}
````

MybatisPlus的功能十分强大，还有很多有意义的功能，比如：逻辑删除、自动填充、代码生成等都非常有意义，能很大程度上提高我们的开发效率。

### 五、MybatisPlus与Mybatis XML

Mybatis Plus只是对Mybatis的增强，所以在使用mybatis plus的项目里面仍然可以使用mybatis xml的语法来实现ORM SQL映射（特别是动态SQL的书写）。
但是需要将扫描路径配置进行简单的调整，原始的配置是这样的 mybatis:

````xml
mapper-locations: classpath:generator/*.xml
````

调整之后的配置是这样的 mybatis-plus:

````xml
mapper-locations: classpath:generator/*.xml
````

---
条件构造器使用：

条件构造器用于给如下的Mapper方法传参，通常情况下： updateWrapper用于给update方法传条件参数 queryWrapper用于给delete和select方法传参

````java
public interface BaseMapper<T> extends Mapper<T> {

    int delete(@Param("ew") Wrapper<T> wrapper);

    int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

    T selectOne(@Param("ew") Wrapper<T> queryWrapper);

    Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);

    List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);

    List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);

    IPage<T> selectPage(IPage<T> page, @Param("ew") Wrapper<T> queryWrapper);

    IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param("ew") Wrapper<T> queryWrapper);
}
````

举例一：like 条件构造

````java
String name="字母";  //name不为空
        String email="";   //email为空串
        QueryWrapper<User> query=new QueryWrapper<>();
        query.like(StringUtils.isNotEmpty(name),"name",name)
//因为email为空串，该条件未生效
        .like(StringUtils.isNotEmpty(email),"email",email);

        List<User> list=userMapper.selectList(query);
        list.forEach(System.out::println);
````

QueryWrapper是查询条件构造器，like是一种条件构造函数，还有很多的条件构造函数。请参考：条件构造器

几乎所有的条件构造函数，都提供了condition参数实现动态SQL。也就是参数判断是否返回true，如果返回false，该条件不成立。如email=“”，所以.like(StringUtils.isNotEmpty(email), "
email", email); 的条件不成立。 所以最终的执行SQL，如下(只有name LIKE条件，没有email LIKE 条件)：

```sql
SELECT id, name, age, email
FROM user
WHERE name LIKE %字母%
```

举例二：allEq条件构造器

all表示所有 Eq是equal的缩写表示相等关系 //构造条件

````java
QueryWrapper<User> query=new QueryWrapper<>();
        Map<String, Object> params=new HashMap<>();
        params.put("name","字母哥");
        params.put("age",18);
        params.put("email",null);

// query.allEq(params,false);
        query.allEq((k,v)->!k.equals("name"),params,false);
        List<User> list=userMapper.selectList(query);
        list.forEach(System.out::println);
````

第一个参数是过滤器（可选参数），lambda表达式表示(k, v) -> !k.equals("name")，参数的Key不能是name，所以params.put("name", "字母哥");这个查询条件被过滤掉
第二个参数表示传入所有的params查询参数 第三个参数（可选参数），表示如果值为null是否按IS NULL查询，false则忽略null列的查询，所以params.put("email", null);这个查询条件被过滤掉
最终执行的SQL如下：

````sql
SELECT id, name, age, email
FROM user
WHERE age = ?
````

更多构造器使用方法总结

请参考：官方文档：条件构造器
<img src='https://img.kancloud.cn/0f/8f/0f8fe8849a8181a0b1551342459df560_1314x1380.png'>

二、lambda条件构造器

举例一：

````java
// LambdaQueryWrapper<User> lambdaQ = new QueryWrapper<User>().lambda();
// LambdaQueryWrapper<User> lambdaQ = new LambdaQueryWrapper<>();
LambdaQueryWrapper<User> lambdaQ=Wrappers.lambdaQuery();
        lambdaQ.like(User::getName,"字母")
        .lt(User::getAge,18);
        List<User> list=userMapper.selectList(lambdaQ);
````

lambda条件构造器，最终执行SQL如下：

````sql
SELECT id, name, age, email
FROM user
WHERE name LIKE %字母%
  AND age
    < 18

````

举例二：

````java
List<User> list=new LambdaQueryChainWrapper<User>(userMapper)
        .likeRight(User::getName,"字母")
        .and(q->q.lt(User::getAge,40)
        .or()
        .isNotNull(User::getEmail)
        )
        .list();
        list.forEach(System.out::println);
````

lambda条件构造器，最终执行SQL如下：

````sql
SELECT id, name, age, email
FROM user
WHERE name LIKE '字母%'
  AND (age < 18 OR email IS NOT NULL)
````