Mybatis-Plus快速入门|比Mybatis更简单好用的ORM框架

红太狼 2024-04-06 12:08 176阅读 0赞

## 一. MP简介 ##

我们知道Mybatis属于一个半自动的ORM框架，之所以说Mybatis是一个半自动的ORM框架，原因是它还需要我们自己在注解或是映射文件中编写SQL语句，并没有实现完全的自动化。SQL语句的编写虽然增加了项目和业务需求实现的灵活性，但对一些基本表的操作而言，无疑增加了数据库操作的复杂度，显得没有那么方便。而Mybatis-Plus则是属于全自动的ORM框架，按照开闭原则，在不影响Mybatis现有功能的情况下，实现了对Mybatis的增强。

今天**壹哥**要带大家来学习一下Mybatis-Plus框架。

## 二. Mybatis-Plus特点 ##

MP具有如下特点：

> 1.  通过在实体类中与数据库表进行映射；
> 2.  无需编写SQL语句，简化了CRUD操作；
> 3.  通常适用于单表。

## 三. MP使用 ##

接下来**壹哥**会在SpringBoot项目环境中，带着大家一起使用Mybatis-Plus。

### 1. 新建SpringBoot项目 ###

这个过程**壹哥**在这里就给大家省略了，如果有不熟悉的同学，请参照千锋Java有关SpringBoot的文章自行实现哦。

### 2. 添加核心依赖 ###

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1.tmp</version>
        </dependency>
        
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.8</version>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <version>1.18.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
    </dependencies>

在这里面比较重要的依赖包，就是今天我们要使用的mybatis-plus-boot-starter这个依赖了。

### 3. 创建SpringBoot启动程序 ###

和其他SpringBoot项目的启动程序一样，此处也略过。

### 4. 配置文件 ###

在配置文件中，我们主要编写的是数据库的连接信息，**壹哥**在这里使用的是properties格式的配置文件，也就是application.properties。

spring.datasource.password=数据库账号的登录密码
    spring.datasource.username=数据库登录账号
    spring.datasource.url=jdbc:mysql://localhost:3306/数据库名?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
    spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    server.port=8096
    spring.application.name=MYBATISPLUSSERVER

### 5. 编写实体类 ###

由于mybatis-plus，可以不编写SQL语句。那么Java中的对象，到底该如何与数据库中的表进行映射呢？答案其实就在实体类中！我们可以通过不同的注解来完成实体类和具体表，以及实体类的属性和表中的列进行映射。这也是mybatis-plus中非常关键的一步，具体实现如下：

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    @TableName("emp")  //告知mybatis-plus和数据库中的哪个表关联
    public class User extends Model<User> implements Serializable {
        //主键id
        private int id;  //当实体类的属性名和和表中的列名相同，无需做任何设置
    
        @TableField("name") 
        private String userName; //属性名和列名不一致时设置映射，用userName属性和表中的name列进行关联
    
        private int age;
        private String email;
    }

### 6. 编写dao接口 ###

我们这里的接口中，不必编写任何CRUD方法，只需要继承BaseMapper接口即可。通过阅读源码我们可以发现，在这个接口中其实已经封装了常见的CURD方法，源码如下：

![c5f8b57f5be34b5ea9a929960e076cf8.png][]

所以，实体类中就可以省去CRUD方法的代码实现。

package com.qf.pro.dao;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.qf.pro.pojo.User;
    
    public interface UserDao extends BaseMapper<User> {
        //BaseMapper<User> 默认封装了CRUD方法，通过泛型制定了所操作的实体类及表
    }

### 7. 编写配置类 ###

这样当SpringBoot启动时，就可以扫描到dao层代码所在的包。

package com.qf.mp2103.dao;
    
    import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @MapperScan("com.qf.mp2103.dao")
    public class MybatisPlusConfig {
        @Bean
        public PaginationInterceptor paginationInterceptor(){
    
            return new PaginationInterceptor();
        }
    }

#### 9. 业务实现 ####

我们要在业务逻辑层里调用各种CRUD方法，这也是Mybatis-Plus比较核心、重要的点，MybatisPlus会根据之前的配置自动生成SQL语句。

package com.qf.mp2103.service.impl;
    
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.core.metadata.IPage;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import com.qf.mp2103.dao.UsersDao;
    import com.qf.mp2103.pojo.Users;
    import com.qf.mp2103.service.UsersService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    @Service
    public class UserServiceImpl implements UsersService {
        @Autowired
        private UsersDao usersDao;
        
        @Override
        public List<Users> findUsers() {
            //mybatisplus 自动生成/提供的查询方法
            //由于是无条件查询，参数null
            return usersDao.selectList(null);
        }
    
        @Override
        public List<Users> findUsersByCondition(String name) {
            //创建QueryWrapper对象
            QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
            //通过wrapper对象来设置查询条件
            //参数1：字段表名
            //参数2：所赋值
            //eq  等于
            wrapper.eq("name",name);
    
            return usersDao.selectList(wrapper);
        }
    
        @Override
        public List<Users> findUsersByCondition2(int startAge, int endAge) {
            QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
            //年龄的范围
            wrapper.between("age",startAge,endAge);
            return usersDao.selectList(wrapper);
        }
    
        @Override
        public List<Users> findUsersByCondition3(Users users) {
            //多条件查询
            QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
            //where name='' and age <=
    //        wrapper.eq(true,"name",users.getUserName());
            wrapper.le(true,"age",users.getAge());
            //where name='' or age >=
            wrapper.eq(true,"name",users.getUserName());
            wrapper.ge(false,"age",users.getAge());
            return usersDao.selectList(wrapper);
        }
    
        @Override
        public List<Users> findUsersByCondition4(Users users) {
            //模糊查询
            QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
            //%关键字%
            wrapper.like("name",users.getUserName());
            //%明
            //wrapper.likeLeft()
            //李%
            //wrapper.likeRight();
            return usersDao.selectList(wrapper);
        }
    
        //排序查询
        @Override
        public List<Users> findUsers2() {
            QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
            //设置排序条件
            wrapper.orderByDesc("id");
    
            return usersDao.selectList(wrapper);
        }
    
        @Override
        public List<Users> findUsersByPage(int page, int size) {
            //用于分页查询
            //select * from users  limit X,X
            QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
            int start=(page-1)*size;
            //拼接
            wrapper.last("limit "+start+","+size);
            return usersDao.selectList(wrapper);
        }
    
        @Override
        public List<Users> findUsers3() {
            //查询指定列
            QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
            //设置查询的列
            wrapper.select("id","email");
    
            return usersDao.selectList(wrapper);
        }
    
        @Override
        public boolean addUser(Users users) {
            //添加用户
            int result=usersDao.insert(users);
            return result==1;
        }
    
        @Override
        public boolean deleteUser(int id) {
            //删除用户--单个删除
            int result=usersDao.deleteById(id);
            //批量删除
            //usersDao.deleteBatchIds(List<Integer> list);
            return result==1;
        }
    
        @Override
        public boolean updateUser(Users users) {
            //要求表中的主键列是id的名字，使用id列作为条件
            int result=usersDao.updateById(users);
            //如果主键列的名字不是id,或者条件不是主键id
    //        QueryWrapper<Users> wrapper=new QueryWrapper<Users>();
    //        wrapper.eq("email",users.getEmail());
    //        int result2=usersDao.update(users,wrapper);
            return result==1;
        }
    
        @Override
        public Users findUersById(int id) {
            //根据主键id查询单个对象
            return usersDao.selectById(id);
        }
    
        @Override
        public List<Users> findUsersByIds(List<Integer> list) {
            //根据id批量查询
            return usersDao.selectBatchIds(list);
        }
    
        @Override
        public Map<String,Object> findUsersByPage2(int page, int size) {
            //如果还有其他条件查询，声明条件构造器进行
    
            //创建分页插件对象
            //参数1：显示第几页数据
            //参数2：每页显示几条数据
            Page<Users> page1=new Page<Users>(page,size);
            //根据分页插件对象里的分页条件查询数据
            IPage<Users> iPage=usersDao.selectPage(page1,null);
    
            Map<String,Object> map=new HashMap<String, Object>();
            //获取总记录数  iPage.getTotal()
            map.put("totalCount",iPage.getTotal());
            //获取总页数 iPage.getPages()
            map.put("totalPage",iPage.getPages());
            //获取分页数据
            map.put("data",iPage.getRecords());
            return map;
        }
    
        @Override
        public List<Users> findUsers4(int age1, int age2, String email) {
            QueryWrapper<Users> queryWrapper=new QueryWrapper<Users>();
            queryWrapper.ge("age",age1).le("age",age2).or().likeRight("email",email);
    
            return usersDao.selectList(queryWrapper);
        }
    
        @Override
        public Users findUsers5(int id) {
            //创建实体类对象
            Users user=new Users();
            user.setId(id);
            //声明对象接收查询返回的结果
            Users getUser=user.selectById(id);
            return getUser;
        }
    
        @Override
        public void addUsers2(Users users) {
            //添加方法
            users.insert();
        }
    
        @Override
        public void updateUsers2(Users users) {
            //根据主键更新
            users.updateById();
        }
    
        @Override
        public void deleteUsers2(Users users) {
            //根据主键删除
            users.deleteById();
        }
    
        public Users findOne(String name){
            //根据其他条件查询单个数据，如果多于1条数据，则报异常
            //条件构造器
            QueryWrapper queryWrapper=new QueryWrapper();
            queryWrapper.eq("name",name);
            return usersDao.selectOne(queryWrapper);
        }
        //查询总记录数
        public int getUserCount(){
            //可以声明条件构造器
            return usersDao.selectCount(null);
        }
    
    }

这样通过以上几个步骤，我们就学会了Mybatis-Plus的基本使用，希望今天的文章可以教会大家如何使用Mybatis-Plus。如果你还有疑惑，可以私信**壹哥**哦。

[c5f8b57f5be34b5ea9a929960e076cf8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/3227724899664662a352133ecd6fea02.png